use core::ffi::c_void;
use std::collections::HashMap;
use std::sync::{Mutex, OnceLock};
use super::events;
use super::util::*;
use crate::capi;
use crate::glue;
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DragDataMode {
ReadWrite,
ReadOnly,
Protected,
Disabled,
}
impl DragDataMode {
fn readable(self) -> bool {
matches!(self, DragDataMode::ReadWrite | DragDataMode::ReadOnly)
}
}
#[derive(Clone, Debug, PartialEq)]
pub enum ItemKind {
Text(String),
File { path: Option<std::path::PathBuf>, is_dir: bool },
}
#[derive(Clone, Debug, PartialEq)]
pub struct Item {
pub id: u64,
pub kind: ItemKind,
pub mime: String,
}
pub struct DataTransferData {
pub items: Vec<Item>,
pub drop_effect: String,
pub effect_allowed: String,
pub mode: DragDataMode,
next_id: u64,
}
impl Default for DataTransferData {
fn default() -> Self {
DataTransferData { items: Vec::new(), drop_effect: "none".into(), effect_allowed: "none".into(), mode: DragDataMode::ReadWrite, next_id: 1 }
}
}
pub fn normalize_format(format: &str) -> String {
let f = format.to_ascii_lowercase();
match f.as_str() {
"text" => "text/plain".to_string(),
"url" => "text/uri-list".to_string(),
_ => f,
}
}
impl DataTransferData {
fn text_index(&self, f: &str) -> Option<usize> {
self.items.iter().position(|i| matches!(i.kind, ItemKind::Text(_)) && i.mime == f)
}
pub fn get(&self, format: &str) -> String {
let f = normalize_format(format);
let Some(i) = self.text_index(&f) else { return String::new() };
let ItemKind::Text(data) = &self.items[i].kind else { return String::new() };
if format.eq_ignore_ascii_case("url") {
return data.split(['\r', '\n']).find(|l| !l.is_empty() && !l.starts_with('#')).unwrap_or("").to_string();
}
data.clone()
}
pub fn set(&mut self, format: &str, data: &str) {
let f = normalize_format(format);
if let Some(i) = self.text_index(&f) {
self.items.remove(i);
}
self.push(ItemKind::Text(data.to_string()), f);
}
pub fn clear(&mut self, format: Option<&str>) {
match format {
Some(f) => {
let f = normalize_format(f);
if let Some(i) = self.text_index(&f) {
self.items.remove(i);
}
}
None => self.items.retain(|i| !matches!(i.kind, ItemKind::Text(_))),
}
}
pub fn types(&self) -> Vec<String> {
if self.mode == DragDataMode::Disabled {
return Vec::new();
}
let mut t: Vec<String> = self.items.iter().filter(|i| matches!(i.kind, ItemKind::Text(_))).map(|i| i.mime.clone()).collect();
if self.items.iter().any(|i| matches!(i.kind, ItemKind::File { .. })) {
t.push("Files".into());
}
t
}
fn push(&mut self, kind: ItemKind, mime: String) -> u64 {
let id = self.next_id;
self.next_id += 1;
self.items.push(Item { id, kind, mime });
id
}
fn visible(&self) -> &[Item] {
if self.mode == DragDataMode::Disabled { &[] } else { &self.items }
}
}
struct UiClasses {
ui_event: Class,
mouse: Class,
keyboard: Class,
wheel: Class,
focus: Class,
input: Class,
pointer: Class,
drag: Class,
dt_cls: capi::JSClassRef,
dt: Class,
list_cls: capi::JSClassRef,
list: Class,
item_cls: capi::JSClassRef,
item: Class,
s_dt: *mut c_void,
s_owner: *mut c_void,
define_property: u64,
freeze: u64,
}
unsafe impl Send for UiClasses {}
unsafe impl Sync for UiClasses {}
fn registry() -> &'static Mutex<HashMap<usize, &'static UiClasses>> {
static R: OnceLock<Mutex<HashMap<usize, &'static UiClasses>>> = OnceLock::new();
R.get_or_init(|| Mutex::new(HashMap::new()))
}
fn classes(g: *mut c_void) -> &'static UiClasses {
registry().lock().unwrap().get(&(g as usize)).copied().expect("webapi::uievents not installed")
}
pub type HandleHook = unsafe fn(g: *mut c_void, path: &std::path::Path, is_dir: bool) -> Result<u64, u64>;
fn handle_hooks() -> &'static Mutex<HashMap<usize, HandleHook>> {
static H: OnceLock<Mutex<HashMap<usize, HandleHook>>> = OnceLock::new();
H.get_or_init(|| Mutex::new(HashMap::new()))
}
pub(crate) fn forget(gone: crate::context::Gone) {
registry().lock().unwrap().remove(&gone.key);
handle_hooks().lock().unwrap().remove(&gone.key);
}
unsafe fn slots(g: *mut c_void, this: u64) -> Option<u64> {
let s = get_a(g, this, state(g).s_event);
if is_cell(s) { Some(s) } else { None }
}
unsafe fn num(g: *mut c_void, v: u64, default: f64) -> u64 {
if v == UNDEF { enc_f64(default) } else { enc_f64(read_number(g, v)) }
}
unsafe fn flag(g: *mut c_void, v: u64) -> u64 {
enc_bool(to_bool(g, v))
}
fn obj_or_null(v: u64) -> u64 {
if v == UNDEF { NULL } else { v }
}
unsafe fn string_or(g: *mut c_void, v: u64, default: &str) -> u64 {
if v == UNDEF {
js_string(g, default)
} else if glue::rjs_kind(g, v) == 5 {
v
} else {
js_string(g, &read_string(g, v).unwrap_or_default())
}
}
unsafe fn nullable_string(g: *mut c_void, v: u64) -> u64 {
if v == UNDEF || v == NULL { NULL } else { string_or(g, v, "") }
}
fn to_uint32(d: f64) -> u32 {
if !d.is_finite() || d == 0.0 {
return 0;
}
d.trunc().rem_euclid(4_294_967_296.0) as u32
}
unsafe fn uint32(g: *mut c_void, v: u64) -> u64 {
if v == UNDEF { enc_f64(0.0) } else { enc_f64(to_uint32(read_number(g, v)) as f64) }
}
const KEY_LOCATIONS: &[(&str, i32)] = &[
("DOM_KEY_LOCATION_STANDARD", 0),
("DOM_KEY_LOCATION_LEFT", 1),
("DOM_KEY_LOCATION_RIGHT", 2),
("DOM_KEY_LOCATION_NUMPAD", 3),
];
const DELTA_MODES: &[(&str, i32)] =
&[("DOM_DELTA_PIXEL", 0), ("DOM_DELTA_LINE", 1), ("DOM_DELTA_PAGE", 2)];
const UI: &[&str] = &["view", "detail", "which"];
pub(crate) unsafe fn init_ui_event(g: *mut c_void, obj: u64, ty: u64, init: u64) {
ui_slots(g, obj, ty, init);
}
unsafe fn ui_slots(g: *mut c_void, obj: u64, ty: u64, init: u64) -> u64 {
let s = events::init_event_slots(g, obj, ty, init, false);
let mut m = [UNDEF; 3];
get_many(g, init, UI, &mut m);
define_many(g, s, UI, &[obj_or_null(m[0]), num(g, m[1], 0.0), num(g, m[2], 0.0)], 0);
s
}
const MOUSE: &[&str] = &[
"screenX", "screenY", "clientX", "clientY", "offsetX", "offsetY", "movementX", "movementY",
"button", "buttons", "ctrlKey", "shiftKey", "altKey", "metaKey", "relatedTarget", "which",
];
unsafe fn init_mouse_event(g: *mut c_void, obj: u64, ty: u64, init: u64) -> u64 {
let s = ui_slots(g, obj, ty, init);
let mut m = [UNDEF; 15];
get_many(g, init, &MOUSE[..15], &mut m);
let mut v = [UNDEF; 16];
for i in 0..10 {
v[i] = num(g, m[i], 0.0);
}
for i in 10..14 {
v[i] = flag(g, m[i]);
}
v[14] = obj_or_null(m[14]);
v[15] = enc_f64(dec_f64(v[8]).unwrap_or(0.0) + 1.0);
define_many(g, s, MOUSE, &v, 0);
s
}
unsafe fn init_mouse(g: *mut c_void, obj: u64, ty: u64, init: u64) {
init_mouse_event(g, obj, ty, init);
}
const KEYBOARD: &[&str] = &["key", "code", "location", "ctrlKey", "shiftKey", "altKey", "metaKey", "repeat", "isComposing"];
unsafe fn init_keyboard_event(g: *mut c_void, obj: u64, ty: u64, init: u64) {
let s = ui_slots(g, obj, ty, init);
let mut m = [UNDEF; 9];
get_many(g, init, KEYBOARD, &mut m);
let mut v = [UNDEF; 9];
v[0] = string_or(g, m[0], "");
v[1] = string_or(g, m[1], "");
v[2] = uint32(g, m[2]);
for i in 3..9 {
v[i] = flag(g, m[i]);
}
define_many(g, s, KEYBOARD, &v, 0);
}
const WHEEL: &[&str] = &["deltaX", "deltaY", "deltaZ", "deltaMode"];
unsafe fn init_wheel_event(g: *mut c_void, obj: u64, ty: u64, init: u64) {
let s = init_mouse_event(g, obj, ty, init);
let mut m = [UNDEF; 4];
get_many(g, init, WHEEL, &mut m);
define_many(g, s, WHEEL, &[num(g, m[0], 0.0), num(g, m[1], 0.0), num(g, m[2], 0.0), uint32(g, m[3])], 0);
}
const FOCUS: &[&str] = &["relatedTarget"];
unsafe fn init_focus_event(g: *mut c_void, obj: u64, ty: u64, init: u64) {
let s = ui_slots(g, obj, ty, init);
let mut m = [UNDEF; 1];
get_many(g, init, FOCUS, &mut m);
define_many(g, s, FOCUS, &[obj_or_null(m[0])], 0);
}
const INPUT: &[&str] = &["data", "inputType", "isComposing"];
unsafe fn init_input_event(g: *mut c_void, obj: u64, ty: u64, init: u64) {
let s = ui_slots(g, obj, ty, init);
let mut m = [UNDEF; 3];
get_many(g, init, INPUT, &mut m);
define_many(g, s, INPUT, &[nullable_string(g, m[0]), string_or(g, m[1], ""), flag(g, m[2])], 0);
}
const POINTER: &[&str] = &[
"pointerId", "width", "height", "pressure", "tangentialPressure", "tiltX", "tiltY", "twist",
"altitudeAngle", "azimuthAngle", "pointerType", "isPrimary",
];
const POINTER_DEFAULTS: [f64; 10] = [0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, std::f64::consts::FRAC_PI_2, 0.0];
fn to_int32(d: f64) -> i32 {
if !d.is_finite() {
return 0;
}
d.trunc().rem_euclid(4_294_967_296.0) as u32 as i32
}
fn tilt_to_spherical(tilt_x: f64, tilt_y: f64) -> (f64, f64) {
use std::f64::consts::{FRAC_PI_2, PI};
let (xr, yr) = (tilt_x.to_radians(), tilt_y.to_radians());
let flat = tilt_x.abs() == 90.0 || tilt_y.abs() == 90.0;
let azimuth = if tilt_x == 0.0 {
if tilt_y > 0.0 {
FRAC_PI_2
} else if tilt_y < 0.0 {
3.0 * FRAC_PI_2
} else {
0.0
}
} else if tilt_y == 0.0 {
if tilt_x < 0.0 { PI } else { 0.0 }
} else if flat {
0.0
} else {
let a = yr.tan().atan2(xr.tan());
if a < 0.0 { a + 2.0 * PI } else { a }
};
let altitude = if flat {
0.0
} else if tilt_x == 0.0 {
FRAC_PI_2 - yr.abs()
} else if tilt_y == 0.0 {
FRAC_PI_2 - xr.abs()
} else {
(1.0 / (xr.tan().powi(2) + yr.tan().powi(2)).sqrt()).atan()
};
(altitude, azimuth)
}
fn spherical_to_tilt(altitude: f64, azimuth: f64) -> (f64, f64) {
use std::f64::consts::{FRAC_PI_2, PI};
if altitude != 0.0 {
let t = altitude.tan();
return ((azimuth.cos() / t).atan().to_degrees(), (azimuth.sin() / t).atan().to_degrees());
}
let (x, y) = if azimuth == 0.0 || azimuth == 2.0 * PI {
(FRAC_PI_2, 0.0)
} else if azimuth == FRAC_PI_2 {
(0.0, FRAC_PI_2)
} else if azimuth == PI {
(-FRAC_PI_2, 0.0)
} else if azimuth == 3.0 * FRAC_PI_2 {
(0.0, -FRAC_PI_2)
} else if azimuth < FRAC_PI_2 {
(FRAC_PI_2, FRAC_PI_2)
} else if azimuth < PI {
(-FRAC_PI_2, FRAC_PI_2)
} else if azimuth < 3.0 * FRAC_PI_2 {
(-FRAC_PI_2, -FRAC_PI_2)
} else {
(FRAC_PI_2, -FRAC_PI_2)
};
(x.to_degrees(), y.to_degrees())
}
const POINTER_LISTS: &[&str] = &["coalescedEvents", "predictedEvents"];
unsafe fn pointer_list(g: *mut c_void, v: u64, member: &str) -> Result<u64, ()> {
let out = new_array(g);
if v == UNDEF {
return Ok(out);
}
if !is_cell(v) {
throw_type_error(g, &format!("PointerEvent constructor: {member} is not a sequence"));
return Err(());
}
let proto = classes(g).pointer.proto;
let n = read_number(g, get(g, v, "length"));
let n = if n.is_finite() && n > 0.0 { n.min(u32::MAX as f64) as u32 } else { 0 };
for i in 0..n {
let e = get_i(g, v, i);
if !proto_chain_has(g, e, proto) {
throw_type_error(g, &format!("PointerEvent constructor: {member}[{i}] is not a PointerEvent"));
return Err(());
}
set_i(g, out, i, e);
}
Ok(out)
}
unsafe fn init_pointer_event(g: *mut c_void, obj: u64, ty: u64, init: u64) -> Result<(), ()> {
let s = init_mouse_event(g, obj, ty, init);
let mut m = [UNDEF; 12];
get_many(g, init, POINTER, &mut m);
let mut v = [UNDEF; 12];
for i in 0..10 {
v[i] = num(g, m[i], POINTER_DEFAULTS[i]);
}
let number = |v: u64| dec_f64(v).unwrap_or(0.0);
let (tilt_given, angles_given) = (m[5] != UNDEF || m[6] != UNDEF, m[8] != UNDEF || m[9] != UNDEF);
if tilt_given && !angles_given {
let (altitude, azimuth) = tilt_to_spherical(
to_int32(number(v[5])) as f64,
to_int32(number(v[6])) as f64,
);
v[8] = enc_f64(altitude);
v[9] = enc_f64(azimuth);
} else if angles_given && !tilt_given {
let (x, y) = spherical_to_tilt(number(v[8]), number(v[9]));
v[5] = enc_f64(x.round());
v[6] = enc_f64(y.round());
}
for i in [5, 6, 7] {
v[i] = enc_f64(to_int32(number(v[i])) as f64);
}
v[10] = string_or(g, m[10], "");
v[11] = flag(g, m[11]);
define_many(g, s, POINTER, &v, 0);
let mut lists = [UNDEF; 2];
get_many(g, init, POINTER_LISTS, &mut lists);
let coalesced = pointer_list(g, lists[0], "coalescedEvents")?;
let predicted = pointer_list(g, lists[1], "predictedEvents")?;
define_many(g, s, POINTER_LISTS, &[coalesced, predicted], 0);
Ok(())
}
const DRAG: &[&str] = &["dataTransfer"];
unsafe fn slot_get(g: *mut c_void, cf: *mut c_void, key: &'static str, label: &str) -> u64 {
match get_in(g, cf_this(cf), state(g).s_event, key) {
Some(v) if v == UNDEF => NULL,
Some(v) => v,
None => throw_type_error(g, &format!("{label} called on a non-Event")),
}
}
macro_rules! slot_getters {
($($fn_name:ident, $key:literal, $label:literal;)*) => {
$(
#[crate::host_fn]
unsafe fn $fn_name(g: *mut c_void, cf: *mut c_void) -> u64 {
slot_get(g, cf, $key, $label)
}
)*
};
}
slot_getters! {
ui_view, "view", "UIEvent.view";
ui_detail, "detail", "UIEvent.detail";
ui_which, "which", "UIEvent.which";
m_screen_x, "screenX", "MouseEvent.screenX";
m_screen_y, "screenY", "MouseEvent.screenY";
m_client_x, "clientX", "MouseEvent.clientX";
m_client_y, "clientY", "MouseEvent.clientY";
m_offset_x, "offsetX", "MouseEvent.offsetX";
m_offset_y, "offsetY", "MouseEvent.offsetY";
m_movement_x, "movementX", "MouseEvent.movementX";
m_movement_y, "movementY", "MouseEvent.movementY";
m_button, "button", "MouseEvent.button";
m_buttons, "buttons", "MouseEvent.buttons";
m_ctrl, "ctrlKey", "MouseEvent.ctrlKey";
m_shift, "shiftKey", "MouseEvent.shiftKey";
m_alt, "altKey", "MouseEvent.altKey";
m_meta, "metaKey", "MouseEvent.metaKey";
m_related, "relatedTarget", "MouseEvent.relatedTarget";
k_key, "key", "KeyboardEvent.key";
k_code, "code", "KeyboardEvent.code";
k_location, "location", "KeyboardEvent.location";
k_repeat, "repeat", "KeyboardEvent.repeat";
k_composing, "isComposing", "KeyboardEvent.isComposing";
k_ctrl, "ctrlKey", "KeyboardEvent.ctrlKey";
k_shift, "shiftKey", "KeyboardEvent.shiftKey";
k_alt, "altKey", "KeyboardEvent.altKey";
k_meta, "metaKey", "KeyboardEvent.metaKey";
w_delta_x, "deltaX", "WheelEvent.deltaX";
w_delta_y, "deltaY", "WheelEvent.deltaY";
w_delta_z, "deltaZ", "WheelEvent.deltaZ";
w_delta_mode, "deltaMode", "WheelEvent.deltaMode";
f_related, "relatedTarget", "FocusEvent.relatedTarget";
i_data, "data", "InputEvent.data";
i_input_type, "inputType", "InputEvent.inputType";
i_composing, "isComposing", "InputEvent.isComposing";
p_id, "pointerId", "PointerEvent.pointerId";
p_width, "width", "PointerEvent.width";
p_height, "height", "PointerEvent.height";
p_pressure, "pressure", "PointerEvent.pressure";
p_tangential, "tangentialPressure", "PointerEvent.tangentialPressure";
p_tilt_x, "tiltX", "PointerEvent.tiltX";
p_tilt_y, "tiltY", "PointerEvent.tiltY";
p_twist, "twist", "PointerEvent.twist";
p_altitude, "altitudeAngle", "PointerEvent.altitudeAngle";
p_azimuth, "azimuthAngle", "PointerEvent.azimuthAngle";
p_type, "pointerType", "PointerEvent.pointerType";
p_primary, "isPrimary", "PointerEvent.isPrimary";
d_data_transfer, "dataTransfer", "DragEvent.dataTransfer";
}
#[crate::host_fn]
unsafe fn m_page_x(g: *mut c_void, cf: *mut c_void) -> u64 {
slot_get(g, cf, "clientX", "MouseEvent.pageX")
}
#[crate::host_fn]
unsafe fn m_page_y(g: *mut c_void, cf: *mut c_void) -> u64 {
slot_get(g, cf, "clientY", "MouseEvent.pageY")
}
#[crate::host_fn]
unsafe fn m_x(g: *mut c_void, cf: *mut c_void) -> u64 {
slot_get(g, cf, "clientX", "MouseEvent.x")
}
#[crate::host_fn]
unsafe fn m_y(g: *mut c_void, cf: *mut c_void) -> u64 {
slot_get(g, cf, "clientY", "MouseEvent.y")
}
unsafe fn modifier_state(g: *mut c_void, cf: *mut c_void, label: &str) -> u64 {
let key = read_string(g, cf_arg(cf, 0)).unwrap_or_default();
let Some(s) = slots(g, cf_this(cf)) else {
return throw_type_error(g, &format!("{label} called on a non-Event"));
};
let slot = match key.as_str() {
"Control" => "ctrlKey",
"Shift" => "shiftKey",
"Alt" => "altKey",
"Meta" => "metaKey",
_ => return FALSE,
};
enc_bool(truthy_flag(get(g, s, slot)))
}
#[crate::host_fn]
unsafe fn m_get_modifier_state(g: *mut c_void, cf: *mut c_void) -> u64 {
modifier_state(g, cf, "MouseEvent.getModifierState")
}
#[crate::host_fn]
unsafe fn k_get_modifier_state(g: *mut c_void, cf: *mut c_void) -> u64 {
modifier_state(g, cf, "KeyboardEvent.getModifierState")
}
unsafe fn p_list(g: *mut c_void, cf: *mut c_void, key: &'static str, label: &str) -> u64 {
let list = slot_get(g, cf, key, label);
let out = new_array(g);
if is_cell(list) {
for i in 0..array_len(g, list) {
set_i(g, out, i, get_i(g, list, i));
}
}
out
}
#[crate::host_fn]
unsafe fn p_coalesced(g: *mut c_void, cf: *mut c_void) -> u64 {
p_list(g, cf, "coalescedEvents", "PointerEvent.getCoalescedEvents")
}
#[crate::host_fn]
unsafe fn p_predicted(g: *mut c_void, cf: *mut c_void) -> u64 {
p_list(g, cf, "predictedEvents", "PointerEvent.getPredictedEvents")
}
macro_rules! event_ctor {
($name:ident, $field:ident, $init:path, $label:literal) => {
#[crate::host_fn]
unsafe fn $name(g: *mut c_void, cf: *mut c_void) -> u64 {
if cf_argc(cf) < 1 {
return throw_type_error(g, concat!($label, " constructor requires a type argument"));
}
let c = classes(g);
let obj = ordinary_create(g, cf_new_target(cf), c.$field.proto);
$init(g, obj, cf_arg(cf, 0), cf_arg(cf, 1));
obj
}
};
}
event_ctor!(ui_construct, ui_event, init_ui_event, "UIEvent");
event_ctor!(mouse_construct, mouse, init_mouse, "MouseEvent");
event_ctor!(keyboard_construct, keyboard, init_keyboard_event, "KeyboardEvent");
event_ctor!(wheel_construct, wheel, init_wheel_event, "WheelEvent");
event_ctor!(focus_construct, focus, init_focus_event, "FocusEvent");
event_ctor!(input_construct, input, init_input_event, "InputEvent");
#[crate::host_fn]
unsafe fn pointer_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
if cf_argc(cf) < 1 {
return throw_type_error(g, "PointerEvent constructor requires a type argument");
}
let c = classes(g);
let obj = ordinary_create(g, cf_new_target(cf), c.pointer.proto);
match init_pointer_event(g, obj, cf_arg(cf, 0), cf_arg(cf, 1)) {
Ok(()) => obj,
Err(()) => UNDEF,
}
}
#[crate::host_fn]
unsafe fn drag_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
if cf_argc(cf) < 1 {
return throw_type_error(g, "DragEvent constructor requires a type argument");
}
let c = classes(g);
let obj = ordinary_create(g, cf_new_target(cf), c.drag.proto);
let s = init_mouse_event(g, obj, cf_arg(cf, 0), cf_arg(cf, 1));
let mut m = [UNDEF; 1];
get_many(g, cf_arg(cf, 1), DRAG, &mut m);
define_many(g, s, DRAG, &[obj_or_null(m[0])], 0);
obj
}
unsafe fn dt_of<'a>(g: *mut c_void, v: u64) -> Option<&'a mut DataTransferData> {
host_data::<DataTransferData>(g, classes(g).dt_cls, v)
}
unsafe fn this_dt<'a>(g: *mut c_void, cf: *mut c_void) -> Option<&'a mut DataTransferData> {
dt_of(g, cf_this(cf))
}
unsafe fn bag(g: *mut c_void, dt: u64) -> u64 {
get_a(g, dt, classes(g).s_dt)
}
unsafe fn make_dt(g: *mut c_void, proto: u64, data: DataTransferData) -> u64 {
let c = classes(g);
let dt = host_create(g, c.dt_cls, proto, data);
let b = new_object(g, NULL);
define(g, b, "files", new_object(g, NULL), 0);
define(g, b, "objs", new_object(g, NULL), 0);
let list = host_create(g, c.list_cls, c.list.proto, DtListData { shown: 0 });
glue::rjs_define(g, list, c.s_owner, dt, 1 | 2 | 4);
define(g, b, "list", list, 0);
glue::rjs_define(g, dt, c.s_dt, b, 1 | 2 | 4);
dt
}
#[crate::host_fn]
unsafe fn dt_construct(g: *mut c_void, cf: *mut c_void) -> u64 {
let c = classes(g);
let proto = ordinary_create_proto(g, cf_new_target(cf), c.dt.proto);
make_dt(g, proto, DataTransferData::default())
}
unsafe fn ordinary_create_proto(g: *mut c_void, new_target: u64, fallback: u64) -> u64 {
let p = if is_cell(new_target) { get(g, new_target, "prototype") } else { UNDEF };
if is_cell(p) { p } else { fallback }
}
unsafe fn item_obj(g: *mut c_void, dt: u64, id: u64) -> u64 {
let c = classes(g);
let objs = get(g, bag(g, dt), "objs");
let key = id.to_string();
let v = get(g, objs, &key);
if is_cell(v) {
return v;
}
let o = host_create(g, c.item_cls, c.item.proto, DtItemData { id });
glue::rjs_define(g, o, c.s_owner, dt, 1 | 2 | 4);
define(g, objs, &key, o, 0);
o
}
unsafe fn resync(g: *mut c_void, dt: u64) {
let c = classes(g);
let Some(d) = dt_of(g, dt) else { return };
let ids: Vec<u64> = d.visible().iter().map(|i| i.id).collect();
let all: Vec<u64> = d.items.iter().map(|i| i.id).collect();
let b = bag(g, dt);
let list = get(g, b, "list");
let Some(ld) = host_data::<DtListData>(g, c.list_cls, list) else { return };
let shown = ld.shown;
ld.shown = ids.len() as u32;
for i in ids.len() as u32..shown {
let a = atom(g, &i.to_string());
glue::rjs_delete(g, list, a);
glue::rjs_atom_free(g, a);
}
for (i, id) in ids.iter().enumerate() {
let o = item_obj(g, dt, *id);
let desc = new_object(g, NULL);
define(g, desc, "value", o, 0);
define(g, desc, "enumerable", TRUE, 0);
define(g, desc, "configurable", TRUE, 0);
let _ = call(g, c.define_property, UNDEF, &[list, enc_i32(i as i32), desc]);
}
for map in ["files", "objs"] {
let m = get(g, b, map);
let mut keys = UNDEF;
if glue::rjs_own_keys(g, m, &mut keys) != 0 {
continue;
}
for k in 0..array_len(g, keys) {
let Some(name) = read_string(g, get_i(g, keys, k)) else { continue };
if name.parse::<u64>().is_ok_and(|id| !all.contains(&id)) {
let a = atom(g, &name);
glue::rjs_delete(g, m, a);
glue::rjs_atom_free(g, a);
}
}
}
}
unsafe fn string_arg(g: *mut c_void, cf: *mut c_void, i: u32, n: u32, who: &str) -> Result<String, ()> {
let argc = cf_argc(cf);
if argc < n {
throw_type_error(g, &format!("Failed to execute {who}: {n} argument{} required, but only {argc} present.", if n == 1 { "" } else { "s" }));
return Err(());
}
let s = to_js_string(g, cf_arg(cf, i))?;
Ok(read_string(g, s).unwrap_or_default())
}
#[crate::host_fn]
unsafe fn dt_get_data(g: *mut c_void, cf: *mut c_void) -> u64 {
if this_dt(g, cf).is_none() {
return throw_type_error(g, "DataTransfer.getData called on a non-DataTransfer");
}
let Ok(format) = string_arg(g, cf, 0, 1, "'getData' on 'DataTransfer'") else { return UNDEF };
let Some(d) = this_dt(g, cf) else { return UNDEF };
let v = if d.mode.readable() { d.get(&format) } else { String::new() };
js_string(g, &v)
}
#[crate::host_fn]
unsafe fn dt_set_data(g: *mut c_void, cf: *mut c_void) -> u64 {
if this_dt(g, cf).is_none() {
return throw_type_error(g, "DataTransfer.setData called on a non-DataTransfer");
}
let Ok(format) = string_arg(g, cf, 0, 2, "'setData' on 'DataTransfer'") else { return UNDEF };
let Ok(data) = string_arg(g, cf, 1, 2, "'setData' on 'DataTransfer'") else { return UNDEF };
let Some(d) = this_dt(g, cf) else { return UNDEF };
if d.mode == DragDataMode::ReadWrite {
d.set(&format, &data);
resync(g, cf_this(cf));
}
UNDEF
}
#[crate::host_fn]
unsafe fn dt_clear_data(g: *mut c_void, cf: *mut c_void) -> u64 {
if this_dt(g, cf).is_none() {
return throw_type_error(g, "DataTransfer.clearData called on a non-DataTransfer");
}
let format = if cf_arg(cf, 0) == UNDEF {
None
} else {
let Ok(f) = string_arg(g, cf, 0, 1, "'clearData' on 'DataTransfer'") else { return UNDEF };
Some(f)
};
let Some(d) = this_dt(g, cf) else { return UNDEF };
if d.mode == DragDataMode::ReadWrite {
d.clear(format.as_deref());
resync(g, cf_this(cf));
}
UNDEF
}
#[crate::host_fn]
unsafe fn dt_types(g: *mut c_void, cf: *mut c_void) -> u64 {
let Some(d) = this_dt(g, cf) else {
return throw_type_error(g, "DataTransfer.types called on a non-DataTransfer");
};
let formats = d.types();
let arr = new_array(g);
for (i, f) in formats.iter().enumerate() {
let v = js_string(g, f);
set_i(g, arr, i as u32, v);
}
let _ = call(g, classes(g).freeze, UNDEF, &[arr]);
arr
}
#[crate::host_fn]
unsafe fn dt_files(g: *mut c_void, cf: *mut c_void) -> u64 {
let this = cf_this(cf);
let Some(d) = this_dt(g, cf) else {
return throw_type_error(g, "DataTransfer.files called on a non-DataTransfer");
};
let ids: Vec<u64> = if d.mode.readable() {
d.items.iter().filter(|i| matches!(i.kind, ItemKind::File { .. })).map(|i| i.id).collect()
} else {
Vec::new()
};
let files_map = get(g, bag(g, this), "files");
let files: Vec<u64> = ids.iter().map(|id| get(g, files_map, &id.to_string())).filter(|v| is_cell(*v)).collect();
super::file::create_file_list(g, &files)
}
#[crate::host_fn]
unsafe fn dt_items(g: *mut c_void, cf: *mut c_void) -> u64 {
if this_dt(g, cf).is_none() {
return throw_type_error(g, "DataTransfer.items called on a non-DataTransfer");
}
get(g, bag(g, cf_this(cf)), "list")
}
#[crate::host_fn]
unsafe fn dt_get_drop(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_dt(g, cf) {
Some(d) => {
let v = d.drop_effect.clone();
js_string(g, &v)
}
None => throw_type_error(g, "DataTransfer.dropEffect called on a non-DataTransfer"),
}
}
#[crate::host_fn]
unsafe fn dt_set_drop(g: *mut c_void, cf: *mut c_void) -> u64 {
if this_dt(g, cf).is_none() {
return throw_type_error(g, "DataTransfer.dropEffect called on a non-DataTransfer");
}
let Ok(s) = to_js_string(g, cf_arg(cf, 0)) else { return UNDEF };
let v = read_string(g, s).unwrap_or_default();
if let Some(d) = this_dt(g, cf) {
if matches!(v.as_str(), "none" | "copy" | "link" | "move") {
d.drop_effect = v;
}
}
UNDEF
}
#[crate::host_fn]
unsafe fn dt_get_effect(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_dt(g, cf) {
Some(d) => {
let v = d.effect_allowed.clone();
js_string(g, &v)
}
None => throw_type_error(g, "DataTransfer.effectAllowed called on a non-DataTransfer"),
}
}
#[crate::host_fn]
unsafe fn dt_set_effect(g: *mut c_void, cf: *mut c_void) -> u64 {
if this_dt(g, cf).is_none() {
return throw_type_error(g, "DataTransfer.effectAllowed called on a non-DataTransfer");
}
let Ok(s) = to_js_string(g, cf_arg(cf, 0)) else { return UNDEF };
let v = read_string(g, s).unwrap_or_default();
if let Some(d) = this_dt(g, cf) {
let known = matches!(v.as_str(), "none" | "copy" | "copyLink" | "copyMove" | "link" | "linkMove" | "move" | "all" | "uninitialized");
if known && d.mode == DragDataMode::ReadWrite {
d.effect_allowed = v;
}
}
UNDEF
}
#[crate::host_fn]
unsafe fn dt_noop(_g: *mut c_void, _cf: *mut c_void) -> u64 {
UNDEF
}
struct DtListData {
shown: u32,
}
unsafe fn owner<'a>(g: *mut c_void, v: u64) -> Option<(u64, &'a mut DataTransferData)> {
let dt = get_a(g, v, classes(g).s_owner);
dt_of(g, dt).map(|d| (dt, d))
}
unsafe fn this_list<'a>(g: *mut c_void, cf: *mut c_void, what: &str) -> Result<(u64, &'a mut DataTransferData), u64> {
let c = classes(g);
let this = cf_this(cf);
if host_data::<DtListData>(g, c.list_cls, this).is_none() {
return Err(throw_type_error(g, &format!("DataTransferItemList.{what} called on a non-DataTransferItemList")));
}
owner(g, this).ok_or_else(|| throw_type_error(g, "DataTransferItemList: lost its DataTransfer"))
}
#[crate::host_fn]
unsafe fn list_length(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_list(g, cf, "length") {
Ok((_, d)) => enc_f64(d.visible().len() as f64),
Err(e) => e,
}
}
#[crate::host_fn]
unsafe fn list_add(g: *mut c_void, cf: *mut c_void) -> u64 {
if let Err(e) = this_list(g, cf, "add") {
return e;
}
let argc = cf_argc(cf);
let (kind, mime, file) = if argc >= 2 {
let Ok(data) = string_arg(g, cf, 0, 2, "'add' on 'DataTransferItemList'") else { return UNDEF };
let Ok(ty) = string_arg(g, cf, 1, 2, "'add' on 'DataTransferItemList'") else { return UNDEF };
(ItemKind::Text(data), ty.to_ascii_lowercase(), UNDEF)
} else if argc == 1 {
let f = cf_arg(cf, 0);
if !super::file::is_file(g, f) {
return throw_type_error(g, "Failed to execute 'add' on 'DataTransferItemList': parameter 1 is not of type 'File'.");
}
let mime = super::blob::data_of(g, f).map(|b| b.mime.to_ascii_lowercase()).unwrap_or_default();
(ItemKind::File { path: None, is_dir: false }, mime, f)
} else {
return throw_type_error(g, "Failed to execute 'add' on 'DataTransferItemList': 1 argument required, but only 0 present.");
};
let Ok((dt, d)) = this_list(g, cf, "add") else { return UNDEF };
if d.mode != DragDataMode::ReadWrite {
return NULL;
}
if matches!(kind, ItemKind::Text(_)) && d.text_index(&mime).is_some() {
return super::domexception::throw(
g,
"NotSupportedError",
&format!("Failed to execute 'add' on 'DataTransferItemList': An item already exists for type '{mime}'."),
);
}
let id = d.push(kind, mime);
if is_cell(file) {
define(g, get(g, bag(g, dt), "files"), &id.to_string(), file, 0);
}
resync(g, dt);
item_obj(g, dt, id)
}
#[crate::host_fn]
unsafe fn list_remove(g: *mut c_void, cf: *mut c_void) -> u64 {
if let Err(e) = this_list(g, cf, "remove") {
return e;
}
if cf_argc(cf) < 1 {
return throw_type_error(g, "Failed to execute 'remove' on 'DataTransferItemList': 1 argument required, but only 0 present.");
}
let Ok(n) = to_number(g, cf_arg(cf, 0)) else { return UNDEF };
let Ok((dt, d)) = this_list(g, cf, "remove") else { return UNDEF };
match d.mode {
DragDataMode::ReadWrite => {}
_ => {
return super::domexception::throw(
g,
"InvalidStateError",
"Failed to execute 'remove' on 'DataTransferItemList': The list is not writable.",
)
}
}
let i = if n.is_finite() { n.trunc().rem_euclid(4_294_967_296.0) as usize } else { 0 };
if i < d.items.len() {
d.items.remove(i);
resync(g, dt);
}
UNDEF
}
#[crate::host_fn]
unsafe fn list_clear(g: *mut c_void, cf: *mut c_void) -> u64 {
let (dt, d) = match this_list(g, cf, "clear") {
Ok(v) => v,
Err(e) => return e,
};
if d.mode == DragDataMode::ReadWrite {
d.items.clear();
resync(g, dt);
}
UNDEF
}
struct DtItemData {
id: u64,
}
unsafe fn this_item(g: *mut c_void, cf: *mut c_void, what: &str) -> Result<Option<(u64, DragDataMode, Item)>, u64> {
let c = classes(g);
let this = cf_this(cf);
let Some(id) = host_data::<DtItemData>(g, c.item_cls, this).map(|d| d.id) else {
return Err(throw_type_error(g, &format!("DataTransferItem.{what} called on a non-DataTransferItem")));
};
let Some((dt, d)) = owner(g, this) else { return Ok(None) };
Ok(d.visible().iter().find(|i| i.id == id).cloned().map(|i| (dt, d.mode, i)))
}
#[crate::host_fn]
unsafe fn item_kind(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_item(g, cf, "kind") {
Ok(Some((_, _, i))) => js_string(g, if matches!(i.kind, ItemKind::Text(_)) { "string" } else { "file" }),
Ok(None) => js_string(g, ""),
Err(e) => e,
}
}
#[crate::host_fn]
unsafe fn item_type(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_item(g, cf, "type") {
Ok(Some((_, _, i))) => js_string(g, &i.mime),
Ok(None) => js_string(g, ""),
Err(e) => e,
}
}
struct AsString {
callback: u64,
data: String,
}
unsafe impl Send for AsString {}
#[crate::host_fn]
unsafe fn item_get_as_string(g: *mut c_void, cf: *mut c_void) -> u64 {
let found = match this_item(g, cf, "getAsString") {
Ok(v) => v,
Err(e) => return e,
};
if cf_argc(cf) < 1 {
return throw_type_error(g, "Failed to execute 'getAsString' on 'DataTransferItem': 1 argument required, but only 0 present.");
}
let cb = cf_arg(cf, 0);
if cb == NULL || cb == UNDEF {
return UNDEF;
}
if glue::rjs_kind(g, cb) != 9 {
return throw_type_error(g, "Failed to execute 'getAsString' on 'DataTransferItem': The callback provided as parameter 1 is not a function.");
}
let Some((_, mode, Item { kind: ItemKind::Text(data), .. })) = found else { return UNDEF };
if !mode.readable() {
return UNDEF;
}
crate::ffi::redjs_protect(g, cb);
let task = AsString { callback: cb, data };
let id = crate::context::id_of(g);
super::blob::queue_task(
g,
Box::new(move |g| unsafe {
let task = task;
if crate::context::id_of(g) != id {
return; }
let s = js_string(g, &task.data);
if let Err(exc) = call(g, task.callback, UNDEF, &[s]) {
crate::errors::report(g, exc, crate::errors::ErrKind::Listener);
}
crate::ffi::redjs_unprotect(g, task.callback);
}),
);
UNDEF
}
#[crate::host_fn]
unsafe fn item_get_as_file(g: *mut c_void, cf: *mut c_void) -> u64 {
match this_item(g, cf, "getAsFile") {
Ok(Some((dt, mode, i))) if mode.readable() && matches!(i.kind, ItemKind::File { .. }) => {
let f = get(g, get(g, bag(g, dt), "files"), &i.id.to_string());
if is_cell(f) { f } else { NULL }
}
Ok(_) => NULL,
Err(e) => e,
}
}
#[crate::host_fn]
unsafe fn item_get_as_handle(g: *mut c_void, cf: *mut c_void) -> u64 {
if host_data::<DtItemData>(g, classes(g).item_cls, cf_this(cf)).is_none() {
let e = super::fetch::make_error(
g,
super::fetch::TYPE_ERR,
"",
"DataTransferItem.getAsFileSystemHandle called on a non-DataTransferItem",
);
return super::domexception::rejected_with(g, e);
}
let found = match this_item(g, cf, "getAsFileSystemHandle") {
Ok(v) => v,
Err(e) => return super::domexception::rejected_with(g, e),
};
let hook = handle_hooks().lock().unwrap().get(&(g as usize)).copied();
let (Some(hook), Some((_, mode, Item { kind: ItemKind::File { path: Some(path), is_dir }, .. }))) = (hook, found) else {
return resolved_promise(g, NULL);
};
if !mode.readable() {
return resolved_promise(g, NULL);
}
match hook(g, &path, is_dir) {
Ok(h) => resolved_promise(g, h),
Err(e) => super::domexception::rejected_with(g, e),
}
}
#[derive(Clone, Debug)]
pub struct DropEntry {
pub path: std::path::PathBuf,
pub is_dir: bool,
pub stat: Option<(u64, std::time::SystemTime)>,
}
pub unsafe fn create_drag_data(g: *mut c_void, entries: &[DropEntry], mode: DragDataMode) -> u64 {
let c = classes(g);
let data = DataTransferData { effect_allowed: "all".into(), drop_effect: "copy".into(), mode, ..DataTransferData::default() };
let dt = make_dt(g, c.dt.proto, data);
let files_map = get(g, bag(g, dt), "files");
for e in entries {
let name = e.path.file_name().map(|n| n.to_string_lossy().into_owned()).unwrap_or_default();
let (size, mtime) = match (e.is_dir, e.stat) {
(false, Some((s, m))) => (s, Some(m)),
(false, None) => super::file::snapshot(&e.path).unwrap_or((0, None)),
(true, _) => (0, e.stat.map(|s| s.1).or_else(|| std::fs::metadata(&e.path).and_then(|m| m.modified()).ok())),
};
if e.is_dir {
super::blob::advise(
"A-F3",
"File (A-F3): a directory was dropped. It appears in dataTransfer.files as a 0-byte File that cannot be \
read, as in Chromium; walk its contents with items[i].getAsFileSystemHandle() where the host provides it."
.to_string(),
);
}
let f = super::file::create_file(g, &e.path, &name, if e.is_dir { Some("") } else { None }, size, mtime, "");
let mime = super::blob::data_of(g, f).map(|b| b.mime.clone()).unwrap_or_default();
let Some(d) = dt_of(g, dt) else { break };
let id = d.push(ItemKind::File { path: Some(e.path.clone()), is_dir: e.is_dir }, mime);
define(g, files_map, &id.to_string(), f, 0);
}
resync(g, dt);
dt
}
pub unsafe fn set_drag_data_mode(g: *mut c_void, dt: u64, mode: DragDataMode) -> bool {
let Some(d) = dt_of(g, dt) else { return false };
d.mode = mode;
resync(g, dt);
true
}
pub unsafe fn set_file_system_handle_hook(g: *mut c_void, hook: Option<HandleHook>) {
match hook {
Some(h) => {
handle_hooks().lock().unwrap().insert(g as usize, h);
}
None => {
handle_hooks().lock().unwrap().remove(&(g as usize));
}
}
let Some(c) = registry().lock().unwrap().get(&(g as usize)).copied() else { return };
define_handle_method(g, c, hook.is_some());
}
unsafe fn define_handle_method(g: *mut c_void, c: &UiClasses, present: bool) {
let a = atom(g, "getAsFileSystemHandle");
if present {
glue::rjs_define(g, c.item.proto, a, make_fn(g, "getAsFileSystemHandle", 0, item_get_as_handle), 2);
} else {
glue::rjs_delete(g, c.item.proto, a);
}
glue::rjs_atom_free(g, a);
}
unsafe fn define_constants(g: *mut c_void, class: &Class, consts: &[(&'static str, i32)]) {
for (name, value) in consts {
define(g, class.ctor, name, enc_i32(*value), 1 | 4);
define(g, class.proto, name, enc_i32(*value), 1 | 4);
}
}
pub unsafe fn install(g: *mut c_void, event_proto: u64) {
let ui_event = define_class(g, &ClassSpec {
name: "UIEvent",
arity: 1,
construct: Some(ui_construct),
parent_proto: event_proto,
methods: &[],
getters: &[("view", ui_view), ("detail", ui_detail), ("which", ui_which)],
accessors: &[],
});
let mouse = define_class(g, &ClassSpec {
name: "MouseEvent",
arity: 1,
construct: Some(mouse_construct),
parent_proto: ui_event.proto,
methods: &[("getModifierState", 1, m_get_modifier_state)],
getters: &[
("screenX", m_screen_x), ("screenY", m_screen_y),
("clientX", m_client_x), ("clientY", m_client_y),
("x", m_x), ("y", m_y),
("pageX", m_page_x), ("pageY", m_page_y),
("offsetX", m_offset_x), ("offsetY", m_offset_y),
("movementX", m_movement_x), ("movementY", m_movement_y),
("button", m_button), ("buttons", m_buttons),
("ctrlKey", m_ctrl), ("shiftKey", m_shift), ("altKey", m_alt), ("metaKey", m_meta),
("relatedTarget", m_related),
],
accessors: &[],
});
let keyboard = define_class(g, &ClassSpec {
name: "KeyboardEvent",
arity: 1,
construct: Some(keyboard_construct),
parent_proto: ui_event.proto,
methods: &[("getModifierState", 1, k_get_modifier_state)],
getters: &[
("key", k_key), ("code", k_code), ("location", k_location),
("repeat", k_repeat), ("isComposing", k_composing),
("ctrlKey", k_ctrl), ("shiftKey", k_shift), ("altKey", k_alt), ("metaKey", k_meta),
],
accessors: &[],
});
define_constants(g, &keyboard, KEY_LOCATIONS);
let wheel = define_class(g, &ClassSpec {
name: "WheelEvent",
arity: 1,
construct: Some(wheel_construct),
parent_proto: mouse.proto,
methods: &[],
getters: &[
("deltaX", w_delta_x), ("deltaY", w_delta_y), ("deltaZ", w_delta_z),
("deltaMode", w_delta_mode),
],
accessors: &[],
});
define_constants(g, &wheel, DELTA_MODES);
let focus = define_class(g, &ClassSpec {
name: "FocusEvent",
arity: 1,
construct: Some(focus_construct),
parent_proto: ui_event.proto,
methods: &[],
getters: &[("relatedTarget", f_related)],
accessors: &[],
});
let input = define_class(g, &ClassSpec {
name: "InputEvent",
arity: 1,
construct: Some(input_construct),
parent_proto: ui_event.proto,
methods: &[],
getters: &[
("data", i_data), ("inputType", i_input_type), ("isComposing", i_composing),
],
accessors: &[],
});
let pointer = define_class(g, &ClassSpec {
name: "PointerEvent",
arity: 1,
construct: Some(pointer_construct),
parent_proto: mouse.proto,
methods: &[
("getCoalescedEvents", 0, p_coalesced),
("getPredictedEvents", 0, p_predicted),
],
getters: &[
("pointerId", p_id), ("width", p_width), ("height", p_height),
("pressure", p_pressure), ("tangentialPressure", p_tangential),
("tiltX", p_tilt_x), ("tiltY", p_tilt_y), ("twist", p_twist),
("altitudeAngle", p_altitude), ("azimuthAngle", p_azimuth),
("pointerType", p_type), ("isPrimary", p_primary),
],
accessors: &[],
});
let dt_cls = make_host_class::<DataTransferData>("DataTransfer");
let dt = define_class(g, &ClassSpec {
name: "DataTransfer",
arity: 0,
construct: Some(dt_construct),
parent_proto: 0,
methods: &[
("getData", 1, dt_get_data),
("setData", 2, dt_set_data),
("clearData", 1, dt_clear_data),
("setDragImage", 3, dt_noop),
],
getters: &[("types", dt_types), ("files", dt_files), ("items", dt_items)],
accessors: &[
("dropEffect", dt_get_drop, dt_set_drop),
("effectAllowed", dt_get_effect, dt_set_effect),
],
});
let list_cls = make_host_class::<DtListData>("DataTransferItemList");
let list = define_class(g, &ClassSpec {
name: "DataTransferItemList",
arity: 0,
construct: None,
parent_proto: 0,
methods: &[("add", 1, list_add), ("remove", 1, list_remove), ("clear", 0, list_clear)],
getters: &[("length", list_length)],
accessors: &[],
});
let global = glue::rjs_global(g);
let values = get(g, get(g, get(g, global, "Array"), "prototype"), "values");
let it = glue::rjs_atom_iterator(g);
glue::rjs_define(g, list.proto, it, values, 2);
glue::rjs_atom_free(g, it);
let item_cls = make_host_class::<DtItemData>("DataTransferItem");
let item = define_class(g, &ClassSpec {
name: "DataTransferItem",
arity: 0,
construct: None,
parent_proto: 0,
methods: &[("getAsString", 1, item_get_as_string), ("getAsFile", 0, item_get_as_file)],
getters: &[("kind", item_kind), ("type", item_type)],
accessors: &[],
});
let object = get(g, global, "Object");
let define_property = get(g, object, "defineProperty");
let freeze = get(g, object, "freeze");
crate::ffi::redjs_protect(g, define_property);
crate::ffi::redjs_protect(g, freeze);
let drag = define_class(g, &ClassSpec {
name: "DragEvent",
arity: 1,
construct: Some(drag_construct),
parent_proto: mouse.proto,
methods: &[],
getters: &[("dataTransfer", d_data_transfer)],
accessors: &[],
});
let boxed: &'static UiClasses = Box::leak(Box::new(UiClasses {
ui_event,
mouse,
keyboard,
wheel,
focus,
input,
pointer,
drag,
dt_cls,
dt,
list_cls,
list,
item_cls,
item,
s_dt: atom_priv(g, "redjs#dataTransfer"),
s_owner: atom_priv(g, "redjs#dataTransferOwner"),
define_property,
freeze,
}));
registry().lock().unwrap().insert(g as usize, boxed);
if handle_hooks().lock().unwrap().contains_key(&(g as usize)) {
define_handle_method(g, boxed, true);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn format_aliases_normalise_the_way_the_spec_says() {
assert_eq!(normalize_format("Text"), "text/plain");
assert_eq!(normalize_format("URL"), "text/uri-list");
assert_eq!(normalize_format("Text/HTML"), "text/html");
}
#[test]
fn setting_the_same_format_twice_replaces_rather_than_appends() {
let mut d = DataTransferData::default();
d.set("text", "a");
d.set("text/plain", "b");
assert_eq!(d.items.len(), 1, "the alias created a second entry: {:?}", d.items);
assert_eq!(d.get("Text"), "b");
}
#[test]
fn a_missing_format_reads_back_as_empty_string_not_a_panic() {
assert_eq!(DataTransferData::default().get("text/plain"), "");
}
#[test]
fn clear_data_with_a_format_removes_only_that_one() {
let mut d = DataTransferData::default();
d.set("text", "a");
d.set("text/html", "b");
d.clear(Some("text"));
assert_eq!(d.get("text/html"), "b");
assert_eq!(d.get("text"), "");
d.clear(None);
assert!(d.items.is_empty());
}
}
#[cfg(test)]
mod jsc_tests {
use crate::webapi::testing::*;
#[test]
fn the_inheritance_chain_reaches_event() {
let c = ctx();
ok(&c, "new MouseEvent('click') instanceof MouseEvent");
ok(&c, "new MouseEvent('click') instanceof UIEvent");
ok(&c, "new MouseEvent('click') instanceof Event");
ok(&c, "new PointerEvent('pointerdown') instanceof MouseEvent");
ok(&c, "new DragEvent('drop') instanceof MouseEvent");
ok(&c, "!(new MouseEvent('click') instanceof PointerEvent)");
}
#[test]
fn init_dictionary_members_read_back() {
let c = ctx();
ok(&c, "(e => e.clientX === 10 && e.clientY === 20 && e.button === 2 && e.ctrlKey === true)\
(new MouseEvent('click', { clientX: 10, clientY: 20, button: 2, ctrlKey: true }))");
ok(&c, "(e => e.x === 10 && e.pageX === 10)(new MouseEvent('click', { clientX: 10 }))");
ok(&c, "(e => e.pointerType === 'pen' && e.pressure === 0.5 && e.isPrimary === true)\
(new PointerEvent('pointerdown', { pointerType: 'pen', pressure: 0.5, isPrimary: true }))");
}
#[test]
fn init_members_convert_by_their_webidl_types() {
let c = ctx();
ok(&c, "(e => e.ctrlKey === true && e.shiftKey === false && e.altKey === false && e.metaKey === true && e.which === 4)\
(new MouseEvent('x', { ctrlKey: 'y', shiftKey: 0, altKey: NaN, metaKey: {}, button: '3' }))");
ok(&c, "(e => e.pointerType === '5' && e.isPrimary === true && e.bubbles === true && e.type === '7')\
(new PointerEvent(7, { pointerType: 5, isPrimary: 1, bubbles: 'yes' }))");
ok(&c, "(e => e.location === 4294967295 && e.key === 'null')(new KeyboardEvent('k', { location: -1, key: null }))");
ok(&c, "(e => e.data === null && e.inputType === '')(new InputEvent('i', { data: null }))");
ok(&c, "(e => e.deltaY === 2 && e.deltaMode === 1 && e.clientX === 3)(new WheelEvent('w', { deltaY: 2, deltaMode: 1.7, clientX: 3 }))");
ok(&c, "new MouseEvent('x', { get clientX() { throw 1 } }).clientX === 0");
}
#[test]
fn coalesced_and_predicted_events_come_from_the_init_dict() {
let c = ctx();
ok(&c, "(() => { const a = new PointerEvent('pointermove', { clientX: 1 }); \
const e = new PointerEvent('pointermove', { coalescedEvents: [a] }); \
const l = e.getCoalescedEvents(); l.pop(); \
return e.getCoalescedEvents()[0] === a && e.getPredictedEvents().length === 0 })()");
ok(&c, "(() => { try { new PointerEvent('p', { coalescedEvents: [new MouseEvent('m')] }); return false } \
catch (e) { return e instanceof TypeError } })()");
ok(&c, "new PointerEvent('p').getCoalescedEvents().length === 0");
}
#[test]
fn tilt_and_angles_fill_each_other_in() {
let c = ctx();
ok(&c, "(e => Math.abs(e.altitudeAngle - Math.PI / 4) < 1e-9 && e.azimuthAngle === 0 && e.tiltY === 0)\
(new PointerEvent('p', { tiltX: 45 }))");
ok(&c, "(e => Math.abs(e.altitudeAngle - Math.PI / 4) < 1e-9 && e.azimuthAngle === 3 * Math.PI / 2)\
(new PointerEvent('p', { tiltY: -45 }))");
ok(&c, "(e => e.tiltX === 0 && e.tiltY === 45)\
(new PointerEvent('p', { altitudeAngle: Math.PI / 4, azimuthAngle: Math.PI / 2 }))");
ok(&c, "(e => e.tiltX === 30 && e.twist === 359)(new PointerEvent('p', { tiltX: 30.9, twist: 359.5 }))");
}
#[test]
fn unset_members_take_their_specified_defaults() {
let c = ctx();
ok(&c, "(e => e.clientX === 0 && e.button === 0 && e.buttons === 0 && e.ctrlKey === false && e.relatedTarget === null)(new MouseEvent('click'))");
ok(&c, "(e => e.width === 1 && e.height === 1 && e.pointerType === '' && e.altitudeAngle === Math.PI / 2)(new PointerEvent('p'))");
}
#[test]
fn offset_coordinates_come_from_the_init_dict_and_do_not_guess() {
let c = ctx();
ok(&c, "new MouseEvent('click', { clientX: 100 }).offsetX === 0");
ok(&c, "new MouseEvent('click', { offsetX: 7 }).offsetX === 7");
}
#[test]
fn get_modifier_state_answers_the_four_tracked_keys() {
let c = ctx();
ok(&c, "new MouseEvent('c', { shiftKey: true }).getModifierState('Shift') === true");
ok(&c, "new MouseEvent('c', { shiftKey: true }).getModifierState('Control') === false");
ok(&c, "new MouseEvent('c').getModifierState('CapsLock') === false");
}
#[test]
fn a_mouse_event_dispatches_through_the_existing_event_target() {
let c = ctx();
s(
&c,
"globalThis.seen = null; const t = new EventTarget(); \
t.addEventListener('click', e => { globalThis.seen = [e.type, e.clientX, e instanceof MouseEvent, e.target === t]; }); \
t.dispatchEvent(new MouseEvent('click', { clientX: 42 })); 'ok'",
);
ok(&c, "globalThis.seen !== null");
ok(&c, "globalThis.seen.join() === 'click,42,true,true'");
}
#[test]
fn prevent_default_still_works_through_the_subclass() {
let c = ctx();
ok(&c, "(() => { const t = new EventTarget(); t.addEventListener('x', e => e.preventDefault()); \
return t.dispatchEvent(new MouseEvent('x', { cancelable: true })) === false; })()");
}
#[test]
fn a_drag_event_carries_its_data_transfer() {
let c = ctx();
ok(
&c,
"(() => { const dt = new DataTransfer(); dt.setData('text', 'hello'); \
const e = new DragEvent('drop', { dataTransfer: dt }); \
return e.dataTransfer === dt && e.dataTransfer.getData('text/plain') === 'hello' \
&& e.dataTransfer.types.join() === 'text/plain'; })()",
);
ok(&c, "new DragEvent('drop').dataTransfer === null");
}
#[test]
fn a_script_made_data_transfer_is_read_write_with_items() {
let c = ctx();
ok(&c, "(() => { const dt = new DataTransfer(); return dt.items === dt.items && dt.items instanceof DataTransferItemList \
&& dt.items.length === 0 && dt.files instanceof FileList && dt.files.length === 0 \
&& dt.dropEffect === 'none' && dt.effectAllowed === 'none'; })()");
ok(&c, "(() => { const dt = new DataTransfer(); dt.setData('text', 'a'); dt.setData('text/html', '<b>'); dt.setData('Text/Plain', 'b'); \
const f = new File(['x'], 'x.txt', { type: 'Text/Plain' }); const it = dt.items.add(f); \
return dt.types.join() === 'text/html,text/plain,Files' && Object.isFrozen(dt.types) && dt.getData('text') === 'b' \
&& dt.items.length === 3 && it === dt.items[2] && it.kind === 'file' && it.type === 'text/plain' && it.getAsFile() === f \
&& dt.files[0] === f && dt.files !== dt.files && [...dt.items].map(i => i.kind).join() === 'string,string,file'; })()");
ok(&c, "(() => { const dt = new DataTransfer(); dt.setData('url', '#c\\r\\nhttps://a.example/\\r\\nhttps://b.example/'); \
return dt.getData('URL') === 'https://a.example/' && dt.getData('text/uri-list').startsWith('#c'); })()");
ok(&c, "(() => { const dt = new DataTransfer(); dt.setData('a', '1'); dt.items.add(new File([], 'f')); dt.clearData(); \
const kept = dt.types.join() === 'Files' && dt.items.length === 1; dt.items.clear(); return kept && dt.items.length === 0 && dt.items[0] === undefined; })()");
assert!(throws(&c, "(() => { const dt = new DataTransfer(); dt.items.add('x', 'a/b'); dt.items.add('y', 'A/B'); })()")
.contains("already exists"));
assert!(throws(&c, "new DataTransfer().items.add('only one')").contains("not of type 'File'"));
ok(&c, "(() => { const dt = new DataTransfer(); const it = dt.items.add('s', 'a/b'); dt.items.remove(0); \
return it.kind === '' && it.type === '' && dt.items.length === 0; })()");
ok(&c, "(() => { const dt = new DataTransfer(); dt.dropEffect = 'bogus'; dt.effectAllowed = 'bogus'; const a = dt.dropEffect + dt.effectAllowed; \
dt.dropEffect = 'move'; dt.effectAllowed = 'copyLink'; return a === 'nonenone' && dt.dropEffect === 'move' && dt.effectAllowed === 'copyLink'; })()");
assert_eq!(
throws(&c, "new DataTransfer().getData()"),
"Failed to execute 'getData' on 'DataTransfer': 1 argument required, but only 0 present."
);
ok(&c, "'getAsFileSystemHandle' in DataTransferItem.prototype === false && !('webkitGetAsEntry' in DataTransferItem.prototype)");
assert!(throws(&c, "new DataTransferItemList()").contains("Illegal constructor"));
assert!(throws(&c, "new DataTransferItem()").contains("Illegal constructor"));
}
#[test]
fn get_as_string_delivers_from_a_task() {
let c = crate::webapi::file::testing::file_ctx();
let r = crate::webapi::file::testing::run(
&c,
"const dt = new DataTransfer(); dt.setData('text', 'hi'); let sync = 'none'; \
const got = new Promise(r => dt.items[0].getAsString(s => { r(s); })); dt.items[0].getAsString(s => { sync = s; }); \
const before = sync; dt.items[0].getAsString(null); dt.items[0].getAsString(undefined); \
let threw = false; try { dt.items[0].getAsString(5); } catch (e) { threw = e instanceof TypeError; } \
return [before, await got, threw].join();",
);
assert_eq!(r, "none,hi,true");
}
#[test]
fn an_os_drop_is_protected_then_read_only_then_disabled() {
use super::{create_drag_data, set_drag_data_mode, DragDataMode, DropEntry};
use crate::webapi::file::testing::{file_ctx, run, TempFile};
let c = file_ctx();
let a = TempFile::new("photo.png", b"PNGDATA");
let dir = std::env::temp_dir().join(format!("redjs-drop-dir-{}", std::process::id()));
std::fs::create_dir_all(&dir).unwrap();
let g = c.raw();
unsafe {
let entries =
[DropEntry { path: a.0.clone(), is_dir: false, stat: None }, DropEntry { path: dir.clone(), is_dir: true, stat: None }];
let dt = create_drag_data(g, &entries, DragDataMode::Protected);
crate::webapi::util::define(g, crate::glue::rjs_global(g), "dt", dt, 0);
ok(&c, "dt.types.join() === 'Files' && dt.items.length === 2 && dt.items[0].kind === 'file' && dt.items[0].type === 'image/png' \
&& dt.files.length === 0 && dt.items[0].getAsFile() === null && dt.effectAllowed === 'all' && dt.dropEffect === 'copy'");
ok(&c, "(() => { dt.setData('x', 'y'); dt.items.add('a', 'b'); return dt.types.join() === 'Files'; })()");
assert!(throws(&c, "dt.items.remove(0)").contains("not writable"));
assert!(set_drag_data_mode(g, dt, DragDataMode::ReadOnly));
ok(&c, "dt.files.length === 2 && dt.files[0].name === 'photo.png' && dt.items[0].getAsFile() === dt.files[0] \
&& dt.files[1].size === 0 && dt.files[1].type === '' && dt.items.add('a', 'b') === null");
assert_eq!(run(&c, "return await dt.files[0].text();"), "PNGDATA");
assert!(run(&c, "return await dt.files[1].text();").starts_with("ERROR: NotReadableError"), "a directory cannot be read");
ok(&c, "(() => { globalThis.kept = dt.items[0]; return true; })()");
set_drag_data_mode(g, dt, DragDataMode::Disabled);
ok(&c, "dt.types.length === 0 && dt.items.length === 0 && dt.items[0] === undefined && dt.files.length === 0 \
&& kept.kind === '' && kept.getAsFile() === null && dt.getData('text') === ''");
assert!(throws(&c, "dt.items.remove(0)").contains("not writable"));
}
assert!(crate::webapi::blob::advisories().iter().any(|m| m.contains("A-F3")));
let _ = std::fs::remove_dir(&dir);
}
#[test]
fn the_file_system_handle_hook_is_called_for_a_dropped_path() {
use super::{create_drag_data, set_drag_data_mode, set_file_system_handle_hook, DragDataMode, DropEntry};
use crate::webapi::file::testing::{file_ctx, run, TempFile};
unsafe fn hook(g: *mut core::ffi::c_void, path: &std::path::Path, is_dir: bool) -> Result<u64, u64> {
let o = crate::webapi::util::new_object(g, crate::webapi::util::UNDEF);
let name = path.file_name().unwrap().to_string_lossy().into_owned();
crate::webapi::util::define(g, o, "name", crate::webapi::util::js_string(g, &name), 0);
crate::webapi::util::define(g, o, "kind", crate::webapi::util::js_string(g, if is_dir { "directory" } else { "file" }), 0);
Ok(o)
}
let c = file_ctx();
let t = TempFile::new("h.txt", b"h");
let g = c.raw();
unsafe {
set_file_system_handle_hook(g, Some(hook));
ok(&c, "typeof DataTransferItem.prototype.getAsFileSystemHandle === 'function'");
ok(&c, "(() => { const p = DataTransferItem.prototype.getAsFileSystemHandle.call({}); globalThis.bad = p; \n p.catch(() => {}); return p instanceof Promise; })()");
assert_eq!(run(&c, "try { await bad; return 'resolved'; } catch (e) { return String(e instanceof TypeError); }"), "true");
let dt = create_drag_data(g, &[DropEntry { path: t.0.clone(), is_dir: false, stat: None }], DragDataMode::Protected);
crate::webapi::util::define(g, crate::glue::rjs_global(g), "dt", dt, 0);
assert_eq!(run(&c, "return String(await dt.items[0].getAsFileSystemHandle());"), "null", "protected: null");
set_drag_data_mode(g, dt, DragDataMode::ReadOnly);
assert_eq!(run(&c, "const h = await dt.items[0].getAsFileSystemHandle(); return h.kind + ':' + h.name;"), "file:h.txt");
assert_eq!(
run(&c, "const d = new DataTransfer(); d.items.add(new File([], 'f')); d.items.add('s', 't'); \
return [await d.items[0].getAsFileSystemHandle(), await d.items[1].getAsFileSystemHandle()].join();"),
",",
"a script-added File and a string item have no handle"
);
set_file_system_handle_hook(g, None);
}
ok(&c, "!('getAsFileSystemHandle' in DataTransferItem.prototype)");
}
#[test]
fn a_getter_on_a_foreign_object_is_a_type_error() {
let c = ctx();
let msg = throws(&c, "Object.getOwnPropertyDescriptor(MouseEvent.prototype,'clientX').get.call({})");
assert!(msg.contains("non-Event"), "{msg}");
}
#[test]
fn a_keyboard_event_is_a_ui_event_and_an_event() {
let c = ctx();
ok(&c, "new KeyboardEvent('keydown') instanceof KeyboardEvent");
ok(&c, "new KeyboardEvent('keydown') instanceof UIEvent");
ok(&c, "new KeyboardEvent('keydown') instanceof Event");
ok(&c, "!(new KeyboardEvent('keydown') instanceof MouseEvent)");
ok(&c, "Object.getPrototypeOf(KeyboardEvent.prototype) === UIEvent.prototype");
ok(&c, "new KeyboardEvent('keydown').type === 'keydown'");
}
#[test]
fn keyboard_event_members_default_the_way_the_spec_says() {
let c = ctx();
ok(
&c,
"(e => e.key === '' && e.code === '' && e.location === 0 && e.repeat === false \
&& e.isComposing === false && e.ctrlKey === false && e.shiftKey === false \
&& e.altKey === false && e.metaKey === false)(new KeyboardEvent('keydown'))",
);
ok(&c, "new KeyboardEvent('keydown', {}).key === ''");
}
#[test]
fn keyboard_event_reads_every_member_back_from_its_init_dictionary() {
let c = ctx();
ok(
&c,
"(e => e.key === 'a' && e.code === 'KeyA' && e.location === 3 && e.repeat === true \
&& e.isComposing === true && e.ctrlKey === true && e.shiftKey === true \
&& e.altKey === true && e.metaKey === true)\
(new KeyboardEvent('keydown', { key: 'a', code: 'KeyA', \
location: KeyboardEvent.DOM_KEY_LOCATION_NUMPAD, repeat: true, isComposing: true, \
ctrlKey: true, shiftKey: true, altKey: true, metaKey: true }))",
);
ok(
&c,
"(e => e.bubbles === true && e.cancelable === true && e.detail === 7 && e.view === null)\
(new KeyboardEvent('keydown', { bubbles: true, cancelable: true, detail: 7 }))",
);
}
#[test]
fn keyboard_event_get_modifier_state_answers_the_four_tracked_keys() {
let c = ctx();
ok(&c, "new KeyboardEvent('k', { ctrlKey: true }).getModifierState('Control') === true");
ok(&c, "new KeyboardEvent('k', { shiftKey: true }).getModifierState('Shift') === true");
ok(&c, "new KeyboardEvent('k', { altKey: true }).getModifierState('Alt') === true");
ok(&c, "new KeyboardEvent('k', { metaKey: true }).getModifierState('Meta') === true");
ok(&c, "new KeyboardEvent('k').getModifierState('Control') === false");
ok(&c, "new KeyboardEvent('k').getModifierState('CapsLock') === false");
}
#[test]
fn the_key_location_constants_sit_on_the_constructor_and_the_prototype() {
let c = ctx();
for owner in ["KeyboardEvent", "KeyboardEvent.prototype"] {
ok(&c, &format!("{owner}.DOM_KEY_LOCATION_STANDARD === 0"));
ok(&c, &format!("{owner}.DOM_KEY_LOCATION_LEFT === 1"));
ok(&c, &format!("{owner}.DOM_KEY_LOCATION_RIGHT === 2"));
ok(&c, &format!("{owner}.DOM_KEY_LOCATION_NUMPAD === 3"));
}
ok(&c, "new KeyboardEvent('k').DOM_KEY_LOCATION_NUMPAD === 3");
ok(
&c,
"(d => d.writable === false && d.configurable === false)\
(Object.getOwnPropertyDescriptor(KeyboardEvent, 'DOM_KEY_LOCATION_LEFT'))",
);
}
#[test]
fn a_cancelable_keyboard_event_can_be_prevented() {
let c = ctx();
ok(&c, "new KeyboardEvent('k').cancelable === false");
ok(
&c,
"(() => { const e = new KeyboardEvent('k', { cancelable: true }); \
e.preventDefault(); return e.defaultPrevented === true; })()",
);
ok(
&c,
"(() => { const e = new KeyboardEvent('k'); e.preventDefault(); \
return e.defaultPrevented === false; })()",
);
ok(
&c,
"(() => { const t = new EventTarget(); t.addEventListener('keydown', e => e.preventDefault()); \
return t.dispatchEvent(new KeyboardEvent('keydown', { cancelable: true })) === false; })()",
);
}
#[test]
fn a_wheel_event_is_a_mouse_event_all_the_way_down() {
let c = ctx();
ok(&c, "new WheelEvent('wheel') instanceof WheelEvent");
ok(&c, "new WheelEvent('wheel') instanceof MouseEvent");
ok(&c, "new WheelEvent('wheel') instanceof UIEvent");
ok(&c, "new WheelEvent('wheel') instanceof Event");
ok(&c, "Object.getPrototypeOf(WheelEvent.prototype) === MouseEvent.prototype");
}
#[test]
fn wheel_deltas_default_to_zero_and_read_back_from_the_init_dictionary() {
let c = ctx();
ok(
&c,
"(e => e.deltaX === 0 && e.deltaY === 0 && e.deltaZ === 0 && e.deltaMode === 0)\
(new WheelEvent('wheel'))",
);
ok(
&c,
"(e => e.deltaX === -1.5 && e.deltaY === 120 && e.deltaZ === 3 && e.deltaMode === 1)\
(new WheelEvent('wheel', { deltaX: -1.5, deltaY: 120, deltaZ: 3, \
deltaMode: WheelEvent.DOM_DELTA_LINE }))",
);
ok(
&c,
"(e => e.clientX === 4 && e.ctrlKey === true && e.buttons === 0 \
&& e.getModifierState('Control') === true)\
(new WheelEvent('wheel', { clientX: 4, ctrlKey: true }))",
);
}
#[test]
fn delta_mode_is_an_enumeration_so_it_is_coerced_to_an_unsigned_long() {
let c = ctx();
ok(&c, "new WheelEvent('wheel', { deltaMode: 1.9 }).deltaMode === 1");
ok(&c, "new WheelEvent('wheel', { deltaMode: NaN }).deltaMode === 0");
ok(&c, "new WheelEvent('wheel', { deltaY: 1.9 }).deltaY === 1.9");
}
#[test]
fn the_delta_mode_constants_sit_on_the_constructor_and_the_prototype() {
let c = ctx();
for owner in ["WheelEvent", "WheelEvent.prototype"] {
ok(&c, &format!("{owner}.DOM_DELTA_PIXEL === 0"));
ok(&c, &format!("{owner}.DOM_DELTA_LINE === 1"));
ok(&c, &format!("{owner}.DOM_DELTA_PAGE === 2"));
}
ok(&c, "new WheelEvent('wheel').DOM_DELTA_PAGE === 2");
}
#[test]
fn a_cancelable_wheel_event_can_be_prevented() {
let c = ctx();
ok(
&c,
"(() => { const t = new EventTarget(); t.addEventListener('wheel', e => e.preventDefault()); \
return t.dispatchEvent(new WheelEvent('wheel', { cancelable: true, deltaY: 10 })) === false; })()",
);
}
#[test]
fn a_focus_event_is_a_ui_event_and_carries_its_related_target() {
let c = ctx();
ok(&c, "new FocusEvent('focus') instanceof FocusEvent");
ok(&c, "new FocusEvent('focus') instanceof UIEvent");
ok(&c, "new FocusEvent('focus') instanceof Event");
ok(&c, "!(new FocusEvent('focus') instanceof MouseEvent)");
ok(&c, "new FocusEvent('blur').relatedTarget === null");
ok(&c, "new FocusEvent('blur', {}).relatedTarget === null");
ok(
&c,
"(() => { const t = new EventTarget(); \
return new FocusEvent('blur', { relatedTarget: t }).relatedTarget === t; })()",
);
ok(&c, "new FocusEvent('focus', { bubbles: true, detail: 2 }).detail === 2");
}
#[test]
fn a_cancelable_focus_event_can_be_prevented() {
let c = ctx();
ok(
&c,
"(() => { const e = new FocusEvent('focusout', { cancelable: true }); \
e.preventDefault(); return e.defaultPrevented === true; })()",
);
}
#[test]
fn an_input_event_is_a_ui_event_with_null_data_by_default() {
let c = ctx();
ok(&c, "new InputEvent('input') instanceof InputEvent");
ok(&c, "new InputEvent('input') instanceof UIEvent");
ok(&c, "new InputEvent('input') instanceof Event");
ok(
&c,
"(e => e.data === null && e.inputType === '' && e.isComposing === false)\
(new InputEvent('input'))",
);
}
#[test]
fn input_event_members_read_back_from_the_init_dictionary() {
let c = ctx();
ok(
&c,
"(e => e.data === 'x' && e.inputType === 'insertText' && e.isComposing === true)\
(new InputEvent('input', { data: 'x', inputType: 'insertText', isComposing: true }))",
);
ok(&c, "new InputEvent('input', { data: null }).data === null");
ok(&c, "new InputEvent('input', { data: '' }).data === ''");
ok(&c, "new InputEvent('beforeinput', { inputType: 'deleteContentBackward' }).data === null");
}
#[test]
fn a_cancelable_input_event_can_be_prevented() {
let c = ctx();
ok(
&c,
"(() => { const t = new EventTarget(); t.addEventListener('beforeinput', e => e.preventDefault()); \
return t.dispatchEvent(new InputEvent('beforeinput', { cancelable: true, data: 'q' })) === false; })()",
);
}
#[test]
fn the_new_classes_require_a_type_and_reject_a_bare_call() {
let c = ctx();
for name in ["KeyboardEvent", "WheelEvent", "FocusEvent", "InputEvent"] {
let msg = throws(&c, &format!("new {name}()"));
assert!(msg.contains("type argument"), "{name}: {msg}");
let msg = throws(&c, &format!("{name}('x')"));
assert!(msg.contains("new"), "{name}: {msg}");
}
}
#[test]
fn the_new_classes_subclass_through_new_target() {
let c = ctx();
for (name, ty) in [
("KeyboardEvent", "keydown"),
("WheelEvent", "wheel"),
("FocusEvent", "focus"),
("InputEvent", "input"),
] {
ok(
&c,
&format!(
"(() => {{ class Sub extends {name} {{ get tag() {{ return 'sub'; }} }} \
const e = new Sub('{ty}', {{ cancelable: true }}); \
return e instanceof Sub && e instanceof {name} && e instanceof Event \
&& e.tag === 'sub' && e.type === '{ty}' && e.cancelable === true; }})()"
),
);
}
}
#[test]
fn the_new_classes_dispatch_through_the_existing_event_target() {
let c = ctx();
s(
&c,
"globalThis.log = []; const t = new EventTarget(); \
t.addEventListener('keydown', e => globalThis.log.push([e.key, e instanceof KeyboardEvent, e.target === t])); \
t.addEventListener('wheel', e => globalThis.log.push([e.deltaY, e instanceof WheelEvent, e.target === t])); \
t.addEventListener('input', e => globalThis.log.push([e.inputType, e instanceof InputEvent, e.target === t])); \
t.dispatchEvent(new KeyboardEvent('keydown', { key: 'Enter' })); \
t.dispatchEvent(new WheelEvent('wheel', { deltaY: 3 })); \
t.dispatchEvent(new InputEvent('input', { inputType: 'insertText' })); 'ok'",
);
ok(&c, "globalThis.log.length === 3");
ok(&c, "globalThis.log.map(r => r.join(':')).join('|') === 'Enter:true:true|3:true:true|insertText:true:true'");
}
#[test]
fn the_new_getters_refuse_a_foreign_receiver() {
let c = ctx();
for (proto, name) in [
("KeyboardEvent", "key"),
("WheelEvent", "deltaY"),
("FocusEvent", "relatedTarget"),
("InputEvent", "inputType"),
] {
let msg = throws(
&c,
&format!("Object.getOwnPropertyDescriptor({proto}.prototype,'{name}').get.call({{}})"),
);
assert!(msg.contains("non-Event"), "{proto}.{name}: {msg}");
assert!(msg.contains(proto), "{proto}.{name}: {msg}");
}
let msg = throws(&c, "KeyboardEvent.prototype.getModifierState.call({}, 'Shift')");
assert!(msg.contains("KeyboardEvent.getModifierState"), "{msg}");
}
}