Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: treat on* handler attributes like any other event listener

Karl Seguin12d04da77209
diff --git a/src/browser/EventManager.zig b/src/browser/EventManager.zig
index ffd9df821..076b6f380 100644
--- a/src/browser/EventManager.zig
+++ b/src/browser/EventManager.zig
@@ -28,12 +28,7 @@ const Event = @import("webapi/Event.zig");
const Window = @import("webapi/Window.zig");
const Element = @import("webapi/Element.zig");
const ShadowRoot = @import("webapi/ShadowRoot.zig");
-const Performance = @import("webapi/Performance.zig");
-const Screen = @import("webapi/Screen.zig");
const EventTarget = @import("webapi/EventTarget.zig");
-const MediaQueryList = @import("webapi/css/MediaQueryList.zig");
-const Animation = @import("webapi/animation/Animation.zig");
-const XMLHttpRequestEventTarget = @import("webapi/net/XMLHttpRequestEventTarget.zig");
const log = lp.log;
@@ -64,7 +59,37 @@ pub fn init(base: *EventManagerBase, frame: *Frame) EventManager {
pub fn register(self: *EventManager, target: *EventTarget, typ: []const u8, callback: Callback, opts: RegisterOptions) !void {
const listener = (try self.base.register(target, typ, callback, opts)) orelse return;
+ self.noteListener(target, listener);
+}
+
+/// Sets (or, with null, clears) the target's `on<typ>` event handler.
+pub fn setHandler(self: *EventManager, target: *EventTarget, typ: []const u8, handler: ?js.Function.Global) !void {
+ const listener = (try self.base.setHandler(target, typ, handler)) orelse return;
+ self.noteListener(target, listener);
+}
+
+/// Sets (or, with null, clears) the target's `on<typ>` event handler from a
+/// content attribute's value.
+pub fn setHandlerSource(self: *EventManager, target: *EventTarget, typ: []const u8, source: ?[]const u8) !void {
+ const listener = (try self.base.setHandlerSource(target, typ, source)) orelse return;
+ self.noteListener(target, listener);
+}
+pub fn getHandler(self: *EventManager, target: *EventTarget, typ: []const u8) ?js.Function.Global {
+ // A content attribute compiles in its target's realm: the element's, or
+ // the Window's for a body/frameset window-reflecting one.
+ const frame = switch (target._type) {
+ .node => target.subtype(Node).ownerFrame(self.frame) orelse self.frame,
+ .window => blk: {
+ const window = target.subtype(Window);
+ break :blk if (window._closed) self.frame else window._frame;
+ },
+ else => self.frame,
+ };
+ return self.base.getHandler(frame.js, target, typ);
+}
+
+fn noteListener(self: *EventManager, target: *EventTarget, listener: *const Listener) void {
if (target._type == .node and listener.typ.eql(comptime .wrap("load"))) {
// optimization so that we avoid firing load for things (e.g. images)
// if there's no load listener regsitered (which is pretty common).
@@ -95,13 +120,7 @@ pub fn dispatch(self: *EventManager, target: *EventTarget, event: *Event) Dispat
switch (target._type) {
.node => try self.dispatchNode(target.subtype(Node), event),
- .xhr => try self.dispatchDirect(target, event, target.subtype(XMLHttpRequestEventTarget).inlineHandler(event._type_string), .{ .context = "dispatch" }),
- .media_query_list => try self.dispatchDirect(target, event, target.subtype(MediaQueryList).inlineHandler(event._type_string), .{ .context = "dispatch" }),
- .animation => try self.dispatchDirect(target, event, target.subtype(Animation).inlineHandler(event._type_string), .{ .context = "dispatch" }),
- .performance => try self.dispatchDirect(target, event, target.subtype(Performance).inlineHandler(event._type_string), .{ .context = "dispatch" }),
- .screen_orientation => try self.dispatchDirect(target, event, target.subtype(Screen.Orientation).inlineHandler(event._type_string), .{ .context = "dispatch" }),
- .window => try self.dispatchDirect(target, event, windowInlineHandler(target.subtype(Window), event._type_string), .{ .context = "dispatch" }),
- else => try self.dispatchDirect(target, event, null, .{ .context = "dispatch" }),
+ else => try self.dispatchDirect(target, event, .{ .context = "dispatch" }),
}
}
@@ -115,32 +134,11 @@ pub fn dispatchCancelable(self: *EventManager, target: *EventTarget, event: *Eve
return event.getDefaultPrevented();
}
-// Resolves the Window's property event handler for the given event type.
-fn windowInlineHandler(window: *Window, typ: lp.String) ?js.Function.Global {
- const global_event_handlers = @import("webapi/global_event_handlers.zig");
- const handler_type = global_event_handlers.fromEventType(typ.str()) orelse return null;
- return switch (handler_type) {
- .onerror => window._on_error,
- .onload => window._on_load,
- .onblur => window._on_blur,
- .onfocus => window._on_focus,
- .onresize => window._on_resize,
- .onscroll => window._on_scroll,
- else => null,
- };
-}
-
-// There are a lot of events that can be attached via addEventListener or as
-// a property, like the XHR events, or window.onload. You might think that the
-// property is just a shortcut for calling addEventListener, but they are distinct.
-// An event set via property cannot be removed by removeEventListener. If you
-// set both the property and add a listener, they both execute.
pub const DispatchDirectOptions = EventManagerBase.DispatchDirectOptions;
-// Direct dispatch for non-DOM targets (Window, XHR, AbortSignal) or DOM nodes with
-// property handlers. No propagation - just calls the handler and registered listeners.
-// Handler can be: null, ?js.Function.Global or js.Function
-pub fn dispatchDirect(self: *EventManager, target: *EventTarget, event: *Event, handler: anytype, comptime opts: DispatchDirectOptions) !void {
+// Direct dispatch for non-DOM targets (Window, XHR, AbortSignal). No
+// propagation - just calls the registered listeners.
+pub fn dispatchDirect(self: *EventManager, target: *EventTarget, event: *Event, comptime opts: DispatchDirectOptions) !void {
const frame = self.frame;
// Set window.event to the currently dispatching event (WHATWG spec)
@@ -149,13 +147,13 @@ pub fn dispatchDirect(self: *EventManager, target: *EventTarget, event: *Event,
window._current_event = event;
defer window._current_event = prev_event;
- try self.base.dispatchDirect(frame.call_arena, frame.js, target, event, handler, frame.page, opts);
+ try self.base.dispatchDirect(frame.js, target, event, frame.page, opts);
}
/// Check if there are any listeners for a direct dispatch (non-DOM target).
/// Use this to avoid creating an event when there are no listeners.
-pub fn hasDirectListeners(self: *EventManager, target: *EventTarget, typ: []const u8, handler: anytype) bool {
- return self.base.hasDirectListeners(target, typ, handler);
+pub fn hasDirectListeners(self: *EventManager, target: *EventTarget, typ: []const u8) bool {
+ return self.base.hasDirectListeners(target, typ);
}
fn dispatchNode(self: *EventManager, target: *Node, event: *Event) !void {
@@ -341,51 +339,20 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event) !void {
if (event._stop_propagation) return;
event._event_phase = .at_target;
- blk: {
- // Get inline handler (e.g., onclick property) for this target
- if (self.getInlineHandler(target_et, event)) |inline_handler| {
- was_handled = true;
- event._current_target = target_et;
-
- const prev_current_event = window._current_event;
- window._current_event = currentEventForTarget(target_et, event);
- defer window._current_event = prev_current_event;
-
- const adjusted: ?AdjustedTargets = if (event._needs_retargeting) .apply(event, target_et) else null;
-
- // Inline handlers (e.g. onclick property) follow the same "report,
- // don't propagate" rule as addEventListener listeners — see Listener.run.
- const handler_return = try callInlineHandler(&ls.local, inline_handler, target_et, event);
- processHandlerReturnValue(event, handler_return);
-
- if (adjusted) |a| {
- a.restore(event);
- }
-
- if (event._stop_propagation) {
- return;
- }
-
- if (event._stop_immediate_propagation) {
- break :blk;
- }
- }
-
- // Per spec, the target is invoked once during the capturing iteration
- // and once during the bubbling iteration, each with its own snapshot
- // of the listener list: a bubble listener added while running the
- // target's capture listeners must run.
- if (self.listenersFor(target_et, event)) |listeners| {
- try self.dispatchPhase(listeners, target_et, event, &was_handled, &ls.local, true);
- if (event._stop_propagation) {
- return;
- }
+ // Per spec, the target is invoked once during the capturing iteration
+ // and once during the bubbling iteration, each with its own snapshot
+ // of the listener list: a bubble listener added while running the
+ // target's capture listeners must run.
+ if (self.listenersFor(target_et, event)) |listeners| {
+ try self.dispatchPhase(listeners, target_et, event, &was_handled, &ls.local, true);
+ if (event._stop_propagation) {
+ return;
}
- if (self.listenersFor(target_et, event)) |listeners| {
- try self.dispatchPhase(listeners, target_et, event, &was_handled, &ls.local, false);
- if (event._stop_propagation) {
- return;
- }
+ }
+ if (self.listenersFor(target_et, event)) |listeners| {
+ try self.dispatchPhase(listeners, target_et, event, &was_handled, &ls.local, false);
+ if (event._stop_propagation) {
+ return;
}
}
@@ -396,33 +363,6 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event) !void {
for (path[1..]) |current_target| {
if (event._stop_propagation) break;
- // Inline handlers (e.g. shadowRoot.onslotchange, div.onclick) are
- // regular non-capture listeners and also fire on ancestors.
- if (self.getInlineHandler(current_target, event)) |inline_handler| {
- was_handled = true;
- event._current_target = current_target;
-
- const prev_current_event = window._current_event;
- window._current_event = currentEventForTarget(current_target, event);
- defer window._current_event = prev_current_event;
-
- const adjusted: ?AdjustedTargets = if (event._needs_retargeting) .apply(event, current_target) else null;
-
- const handler_return = try callInlineHandler(&ls.local, inline_handler, current_target, event);
- processHandlerReturnValue(event, handler_return);
-
- if (adjusted) |a| {
- a.restore(event);
- }
-
- if (event._stop_propagation) {
- break;
- }
- if (event._stop_immediate_propagation) {
- continue;
- }
- }
-
if (self.listenersFor(current_target, event)) |listeners| {
try self.dispatchPhase(listeners, current_target, event, &was_handled, &ls.local, false);
}
@@ -430,13 +370,10 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event) !void {
}
}
-/// Whether a listener on the path could call preventDefault. An inline
-/// handler always can; addEventListener listeners can unless passive.
+/// Whether a listener on the path could call preventDefault: any but a
+/// passive one.
fn anyNonPassive(self: *EventManager, path: []const *EventTarget, event: *Event) bool {
for (path) |target| {
- if (self.getInlineHandler(target, event) != null) {
- return true;
- }
if (self.listenersFor(target, event)) |listeners| {
if (EventManagerBase.hasListener(listeners.list, .non_passive)) {
return true;
@@ -475,35 +412,6 @@ fn legacyType(event: *const Event) ?lp.String {
return null;
}
-// Calls an inline handler (onclick attribute or property). An exception it
-// doesn't catch is reported to the global, as for an addEventListener
-// listener (Listener.run), and dispatch carries on.
-fn callInlineHandler(local: *const js.Local, handler: js.Function.Global, this: *EventTarget, event: *Event) error{ExecutionTerminated}!?js.Value {
- var try_catch: js.TryCatch = undefined;
- try_catch.init(local);
- defer try_catch.deinit();
-
- return local.toLocal(handler).callWithThisRethrow(js.Value, this, .{event}) catch |err| switch (err) {
- error.ExecutionTerminated => return error.ExecutionTerminated,
- error.JsException, error.TryCatchRethrow => {
- Listener.reportException(&try_catch, local);
- return null;
- },
- else => {
- local.ctx.page.recordJsError(err);
- log.debug(.event, "inline handler", .{ .err = err });
- return null;
- },
- };
-}
-
-fn processHandlerReturnValue(event: *Event, handler_return: ?js.Value) void {
- const ret = handler_return orelse return;
- if (ret.isFalse() and !event._type_string.eql(comptime .wrap("error"))) {
- event.preventDefault();
- }
-}
-
// Per spec ("invocation target in shadow tree"), window.event is left
// undefined while invoking listeners whose target lives in a shadow tree.
fn currentEventForTarget(target: *EventTarget, event: *Event) ?*Event {
@@ -533,7 +441,7 @@ fn dispatchPhase(self: *EventManager, listeners: TargetListeners, current_target
if (base.dispatch_depth == 0) {
for (base.deferred_removals.items) |removal| {
removal.list.remove(&removal.listener.node);
- base.listener_pool.destroy(removal.listener);
+ base.destroyListener(removal.listener);
}
base.deferred_removals.clearRetainingCapacity();
}
@@ -587,7 +495,7 @@ fn dispatchPhase(self: *EventManager, listeners: TargetListeners, current_target
// Compute adjusted targets for shadow DOM retargeting (only if needed)
const adjusted: ?AdjustedTargets = if (event._needs_retargeting) .apply(event, current_target) else null;
- try listener.run(frame.call_arena, local, event, "listener");
+ try listener.run(local, event, "listener");
event._in_passive_listener = false;
@@ -601,42 +509,6 @@ fn dispatchPhase(self: *EventManager, listeners: TargetListeners, current_target
}
}
-fn getInlineHandler(self: *EventManager, target: *EventTarget, event: *Event) ?js.Function.Global {
- const global_event_handlers = @import("webapi/global_event_handlers.zig");
- const handler_type = global_event_handlers.fromEventType(event._type_string.str()) orelse return null;
-
- // Non-element targets (e.g. ShadowRoot.onslotchange) only ever set their
- // handler via the property, so the lookup alone covers them.
- if (self.frame._event_target_attr_listeners.get(.{ .target = target, .handler = handler_type })) |cached| {
- return cached;
- }
-
- // Look up the inline handler for this target
- const html_element = switch (target._type) {
- .node => target.subtype(Node).is(Element.Html) orelse return null,
- // The Window stores its event handlers in dedicated fields; an event
- // propagating to the window must fire them too.
- .window => {
- const w = target.subtype(Window);
- return switch (handler_type) {
- .onerror => w._on_error,
- .onload => w._on_load,
- .onblur => w._on_blur,
- .onfocus => w._on_focus,
- .onresize => w._on_resize,
- .onscroll => w._on_scroll,
- else => null,
- };
- },
- else => return null,
- };
-
- return html_element.getAttributeFunction(handler_type, self.frame) catch |err| {
- log.debug(.event, "inline html callback", .{ .type = handler_type, .err = err });
- return null;
- };
-}
-
// An invocation sees the target and the relatedTarget retargeted against its
// own currentTarget (DOM dispatch step 5.7). The event carries the unadjusted
// values in between, so each invocation adjusts and then restores them.
diff --git a/src/browser/EventManagerBase.zig b/src/browser/EventManagerBase.zig
index fd096d5d3..f95a7ab85 100644
--- a/src/browser/EventManagerBase.zig
+++ b/src/browser/EventManagerBase.zig
@@ -24,6 +24,7 @@ const Page = @import("Page.zig");
const Event = @import("webapi/Event.zig");
const EventTarget = @import("webapi/EventTarget.zig");
+const ErrorEvent = @import("webapi/event/ErrorEvent.zig");
const log = lp.log;
const String = lp.String;
@@ -85,8 +86,6 @@ pub fn register(self: *EventManagerBase, target: *EventTarget, typ: []const u8,
.target = target.toString(),
});
}
- const arena = self.arena;
-
// If a signal is provided and already aborted, don't register the listener
if (opts.signal) |signal| {
if (signal.getAborted()) {
@@ -94,22 +93,7 @@ pub fn register(self: *EventManagerBase, target: *EventTarget, typ: []const u8,
}
}
- const gop = try self.lookup.getOrPut(arena, @intFromPtr(target));
- if (gop.found_existing == false) {
- gop.value_ptr.* = .empty;
- }
- const types = gop.value_ptr;
-
- const list, const type_string = blk: {
- if (findType(types.items, .wrap(typ))) |existing| {
- break :blk .{ existing.list, existing.typ };
- }
- const type_string = try String.init(arena, typ, .{});
- const list = try self.list_pool.create(arena);
- list.* = .{};
- try types.append(arena, .{ .typ = type_string, .list = list });
- break :blk .{ list, type_string };
- };
+ const list, const type_string = try self.getOrCreateList(target, typ);
// check for duplicate callbacks already registered. Listeners that
// have been removed (e.g. a `once` listener that fired mid-dispatch
@@ -134,7 +118,7 @@ pub fn register(self: *EventManagerBase, target: *EventTarget, typ: []const u8,
.object => |o| Function{ .object = try o.persist() },
};
- const listener = try self.listener_pool.create(arena);
+ const listener = try self.listener_pool.create(self.arena);
listener.* = .{
.node = .{},
.once = opts.once,
@@ -150,6 +134,87 @@ pub fn register(self: *EventManagerBase, target: *EventTarget, typ: []const u8,
return listener;
}
+// re-setting keeps its order in the list
+pub fn setHandler(self: *EventManagerBase, target: *EventTarget, typ: []const u8, handler: ?js.Function.Global) !?*Listener {
+ return self.setHandlerFunction(target, typ, if (handler) |h| .{ .handler = h } else null);
+}
+
+// An event handler content attribute, compiled on first use. The source must
+// live as long as the page. Currently, the source is always form an attribute
+// entry's slice (attribute values are also tied to the page.arena).
+// As always careful not to use String.str() on a stack-allocated String!
+pub fn setHandlerSource(self: *EventManagerBase, target: *EventTarget, typ: []const u8, source: ?[]const u8) !?*Listener {
+ return self.setHandlerFunction(target, typ, if (source) |s| .{ .handler_source = s } else null);
+}
+
+// The handler's function, compiling a content attribute in `ctx`.
+pub fn getHandler(self: *EventManagerBase, ctx: *js.Context, target: *EventTarget, typ: []const u8) ?js.Function.Global {
+ const list = self.getListeners(target, .wrap(typ)) orelse return null;
+ const listener = findHandler(list) orelse return null;
+ return listener.compileHandler(ctx);
+}
+
+fn setHandlerFunction(self: *EventManagerBase, target: *EventTarget, typ: []const u8, function: ?Function) !?*Listener {
+ if (self.getListeners(target, .wrap(typ))) |list| {
+ if (findHandler(list)) |listener| {
+ if (function) |f| {
+ listener.function.release();
+ listener.function = f;
+ } else {
+ self.removeListener(list, listener);
+ }
+ return null;
+ }
+ }
+ const f = function orelse return null;
+
+ const list, const type_string = try self.getOrCreateList(target, typ);
+ const listener = try self.listener_pool.create(self.arena);
+ listener.* = .{
+ .node = .{},
+ .once = false,
+ .capture = false,
+ .passive = false,
+ .function = f,
+ .typ = type_string,
+ };
+ list.append(&listener.node);
+ return listener;
+}
+
+fn findHandler(list: *const std.DoublyLinkedList) ?*Listener {
+ var node = list.first;
+ while (node) |n| : (node = n.next) {
+ const listener: *Listener = @alignCast(@fieldParentPtr("node", n));
+ if (listener.removed) {
+ continue;
+ }
+ switch (listener.function) {
+ .handler, .handler_source => return listener,
+ .value, .object => {},
+ }
+ }
+ return null;
+}
+
+fn getOrCreateList(self: *EventManagerBase, target: *EventTarget, typ: []const u8) !struct { *std.DoublyLinkedList, String } {
+ const arena = self.arena;
+ const gop = try self.lookup.getOrPut(arena, @intFromPtr(target));
+ if (gop.found_existing == false) {
+ gop.value_ptr.* = .empty;
+ }
+ const types = gop.value_ptr;
+
+ if (findType(types.items, .wrap(typ))) |existing| {
+ return .{ existing.list, existing.typ };
+ }
+ const type_string = try String.init(arena, typ, .{});
+ const list = try self.list_pool.create(arena);
+ list.* = .{};
+ try types.append(arena, .{ .typ = type_string, .list = list });
+ return .{ list, type_string };
+}
+
pub fn remove(self: *EventManagerBase, target: *EventTarget, typ: []const u8, callback: Callback, use_capture: bool) void {
const list = self.getListeners(target, .wrap(typ)) orelse return;
if (findListener(list, callback, use_capture)) |listener| {
@@ -170,10 +235,15 @@ pub fn removeListener(self: *EventManagerBase, list: *std.DoublyLinkedList, list
} else {
// Outside dispatch, remove immediately
list.remove(&listener.node);
- self.listener_pool.destroy(listener);
+ self.destroyListener(listener);
}
}
+pub fn destroyListener(self: *EventManagerBase, listener: *Listener) void {
+ listener.function.release();
+ self.listener_pool.destroy(listener);
+}
+
/// Drops every listener on `target`.
pub fn removeTarget(self: *EventManagerBase, target: *EventTarget) void {
var kv = self.lookup.fetchRemove(@intFromPtr(target)) orelse return;
@@ -195,7 +265,8 @@ pub fn removeTarget(self: *EventManagerBase, target: *EventTarget) void {
/// Check if there are any listeners registered for a target/type combination.
fn hasListeners(self: *EventManagerBase, target: *EventTarget, typ: []const u8) bool {
- return self.getListeners(target, .wrap(typ)) != null;
+ const list = self.getListeners(target, .wrap(typ)) orelse return false;
+ return hasListener(list, .any);
}
/// Get the listener list for a target/type, if any exist.
@@ -249,16 +320,13 @@ pub const DispatchDirectOptions = struct {
run_microtasks: bool = true,
};
-/// Direct dispatch for non-DOM targets. No propagation - just calls the property
-/// handler and registered listeners. Caller is responsible for event ref counting.
-/// Handler can be: null, ?js.Function.Global or js.Function
+/// Direct dispatch for non-DOM targets. No propagation - just calls the
+/// registered listeners. Caller is responsible for event ref counting.
pub fn dispatchDirect(
self: *EventManagerBase,
- arena: Allocator,
ctx: *js.Context,
target: *EventTarget,
event: *Event,
- handler: anytype,
page: *Page,
comptime opts: DispatchDirectOptions,
) DispatchError!void {
@@ -290,9 +358,7 @@ pub fn dispatchDirect(
// dispatchPhase. It is simpler because, for direct dispatching, we know
// there's no ancestors and only the single target phase.
- // Track dispatch depth for deferred removal. Bump it *before* the property
- // handler runs so any listener it removes is deferred (keeping our sentinel
- // node alive) rather than freed mid-dispatch.
+ // Track dispatch depth for deferred removal.
self.dispatch_depth += 1;
defer {
self.dispatch_depth -= 1;
@@ -300,44 +366,17 @@ pub fn dispatchDirect(
if (self.dispatch_depth == 0) {
for (self.deferred_removals.items) |removal| {
removal.list.remove(&removal.listener.node);
- self.listener_pool.destroy(removal.listener);
+ self.destroyListener(removal.listener);
}
self.deferred_removals.clearRetainingCapacity();
}
}
- // Snapshot the listener list *before* invoking the property handler. Per
- // spec the set of listeners is collected at the start of dispatch, so a
- // listener added while we're dispatching — including one added by the
- // property handler itself (e.g. onupgradeneeded calling addEventListener) —
- // must not be invoked for this event.
- const maybe_list = self.getListeners(target, event._type_string);
- const sentinel = if (maybe_list) |list| list.last else null;
-
- // Call the property handler (e.g., onmessage) if present
- if (getFunction(handler, &ls.local)) |func| {
- event._current_target = target;
- // Reported like an exception from an addEventListener listener (see
- // Listener.run), so the global's "error" event / onerror fires.
- var try_catch: js.TryCatch = undefined;
- try_catch.init(&ls.local);
- defer try_catch.deinit();
- func.callWithThisRethrow(void, target, .{event}) catch |err| switch (err) {
- error.ExecutionTerminated => return error.ExecutionTerminated,
- error.JsException, error.TryCatchRethrow => {
- event._listeners_did_throw = true;
- Listener.reportException(&try_catch, &ls.local);
- },
- else => {
- page.recordJsError(err);
- log.debug(.event, opts.context, .{ .err = err });
- },
- };
- }
-
- // No listeners were registered via addEventListener at dispatch start.
- const last_node = sentinel orelse return;
- const list = maybe_list.?;
+ // Per spec the set of listeners is collected at the start of dispatch, so
+ // a listener added while we're dispatching must not be invoked for this
+ // event.
+ const list = self.getListeners(target, event._type_string) orelse return;
+ const last_node = list.last orelse return;
// Use the last listener present at dispatch start as sentinel - listeners
// added during dispatch will be after it
@@ -376,7 +415,7 @@ pub fn dispatchDirect(
event._current_target = target;
event._in_passive_listener = listener.passive;
- try listener.run(arena, &ls.local, event, opts.context);
+ try listener.run(&ls.local, event, opts.context);
event._in_passive_listener = false;
@@ -386,43 +425,12 @@ pub fn dispatchDirect(
}
}
-fn getFunction(handler: anytype, local: *const js.Local) ?js.Function {
- const T = @TypeOf(handler);
- const ti = @typeInfo(T);
-
- if (ti == .null) {
- return null;
- }
- if (ti == .optional) {
- return getFunction(handler orelse return null, local);
- }
- return switch (T) {
- js.Function => handler,
- js.Function.Global => local.toLocal(handler),
- else => @compileError("handler must be null or \\??js.Function(\\.(Temp|Global))?"),
- };
-}
-
/// Check if there are any listeners for a direct dispatch (non-DOM target).
/// Use this to avoid creating an event when there are no listeners.
-pub fn hasDirectListeners(self: *EventManagerBase, target: *EventTarget, typ: []const u8, handler: anytype) bool {
- if (hasHandler(handler)) {
- return true;
- }
+pub fn hasDirectListeners(self: *EventManagerBase, target: *EventTarget, typ: []const u8) bool {
return self.hasListeners(target, typ);
}
-fn hasHandler(handler: anytype) bool {
- const ti = @typeInfo(@TypeOf(handler));
- if (ti == .null) {
- return false;
- }
- if (ti == .optional) {
- return handler != null;
- }
- return true;
-}
-
fn findListener(list: *const std.DoublyLinkedList, callback: Callback, capture: bool) ?*Listener {
var node = list.first;
while (node) |n| {
@@ -466,12 +474,11 @@ pub const Listener = struct {
// listener variant uses it as `this`, matching the spec contract that a
// listener sees its current target via both `event.currentTarget` and `this`.
pub fn run(
- self: *const Listener,
- arena: Allocator,
+ self: *Listener,
local: *const js.Local,
event: *Event,
comptime context: []const u8,
- ) error{ OutOfMemory, ExecutionTerminated }!void {
+ ) error{ExecutionTerminated}!void {
switch (self.function) {
.value => |value| {
var try_catch: js.TryCatch = undefined;
@@ -488,19 +495,9 @@ pub const Listener = struct {
else => log.debug(.event, context, .{ .err = err }),
};
},
- .string => |string| {
- const str = try arena.dupeSentinel(u8, string.str(), 0);
- local.eval(str, null) catch |err| {
- if (err == error.ExecutionTerminated) {
- return error.ExecutionTerminated;
- }
- local.ctx.page.recordJsError(err);
- if (err == error.JsException) {
- event._listeners_did_throw = true;
- } else {
- log.debug(.event, context, .{ .err = err });
- }
- };
+ .handler, .handler_source => {
+ const handler = self.compileHandler(local.ctx) orelse return;
+ try runHandler(local.toLocal(handler), local, event, context);
},
.object => |obj_global| {
const obj = local.toLocal(obj_global);
@@ -548,6 +545,80 @@ pub const Listener = struct {
}
}
+ fn compileHandler(self: *Listener, ctx: *js.Context) ?js.Function.Global {
+ switch (self.function) {
+ .handler => |h| return h,
+ .handler_source => |source| {
+ // compiled on first use (then turned into a handler).
+ // on error, the handler becomes null.
+ var ls: js.Local.Scope = undefined;
+ ctx.localScope(&ls);
+ defer ls.deinit();
+
+ var try_catch: js.TryCatch = undefined;
+ try_catch.init(&ls.local);
+ defer try_catch.deinit();
+
+ const handler: ?js.Function.Global = blk: {
+ const func = ls.local.compileFunction(source, &.{"event"}, &.{}) catch |err| {
+ log.debug(.js, "event handler source", .{ .source = source, .err = err });
+ reportException(&try_catch, &ls.local);
+ break :blk null;
+ };
+ break :blk func.persist() catch null;
+ };
+ self.function = .{ .handler = handler };
+ return handler;
+ },
+ .value, .object => unreachable,
+ }
+ }
+
+ // Runs an on* handler. Returning true cancels the event. Special handling
+ // for the window.onerror's ErrorEvent callback which is decomposed into parameters :/
+ fn runHandler(handler: js.Function, local: *const js.Local, event: *Event, comptime context: []const u8) error{ExecutionTerminated}!void {
+ var try_catch: js.TryCatch = undefined;
+ try_catch.init(local);
+ defer try_catch.deinit();
+
+ const this = event._current_target.?;
+ const error_event: ?*ErrorEvent = blk: {
+ if (this._type != .window and this._type != .worker_global_scope) break :blk null;
+ if (event._type_string.eql(comptime .wrap("error")) == false) break :blk null;
+ break :blk event.is(ErrorEvent);
+ };
+
+ const result = blk: {
+ if (error_event) |e| {
+ break :blk handler.callWithThisRethrow(js.Value, this, .{
+ e._message,
+ e._filename,
+ e._line_number,
+ e._column_number,
+ e._error,
+ });
+ }
+ break :blk handler.callWithThisRethrow(js.Value, this, .{event});
+ } catch |err| switch (err) {
+ error.JsException, error.TryCatchRethrow => {
+ event._listeners_did_throw = true;
+ reportException(&try_catch, local);
+ return;
+ },
+ error.ExecutionTerminated => return error.ExecutionTerminated,
+ else => {
+ local.ctx.page.recordJsError(err);
+ log.debug(.event, context, .{ .err = err });
+ return;
+ },
+ };
+
+ const cancel = if (error_event != null) result.isTrue() else result.isFalse();
+ if (cancel) {
+ event.preventDefault();
+ }
+ }
+
// Reports a listener exception to the relevant global (firing
// window.onerror / an "error" event) without stopping the dispatch.
pub fn reportException(try_catch: *js.TryCatch, local: *const js.Local) void {
@@ -564,8 +635,20 @@ pub const Listener = struct {
pub const Function = union(enum) {
value: js.Function.Global,
- string: String,
object: js.Object.Global,
+ // An event handler (onclick, ...): see setHandler. Null when its content
+ // attribute didn't compile.
+ handler: ?js.Function.Global,
+ handler_source: []const u8,
+
+ fn release(self: Function) void {
+ switch (self) {
+ .value => |f| f.release(),
+ .handler => |h| if (h) |f| f.release(),
+ .object => |o| o.release(),
+ .handler_source => {},
+ }
+ }
fn eqlFunction(self: Function, func: js.Function) bool {
return switch (self) {
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index bffd3f428..39c1a6c56 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -70,8 +70,6 @@ const sys_url = @import("../sys/url.zig");
const HttpClient = @import("../network/HttpClient.zig");
const GlobalScope = @import("global_scope.zig").GlobalScope;
-const GlobalEventHandlersLookup = @import("webapi/global_event_handlers.zig").Lookup;
-
const framing = @import("frame/framing.zig");
pub const parse = @import("frame/parse.zig");
pub const preload = @import("frame/preload.zig");
@@ -120,26 +118,6 @@ _parse_mode: enum { document, fragment, document_write } = .document,
// inserted into a document
_fragment_scripts_runnable: bool = false,
-/// Lazily-created inline event listeners (or listeners provided as attributes).
-/// Avoids bloating all elements with extra function fields for rare usage.
-///
-/// Use this when a listener provided like this:
-///
-/// ```js
-/// img.onload = () => { ... };
-/// ```
-///
-/// Its also used as cache for such cases after lazy evaluation:
-///
-/// ```html
-/// <img onload="(() => { ... })()" />
-/// ```
-///
-/// ```js
-/// img.setAttribute("onload", "(() => { ... })()");
-/// ```
-_event_target_attr_listeners: GlobalEventHandlersLookup = .empty,
-
// FileLists owned by `<input type=file>` elements. Each holds refs on its
// File objects (reference counted via their Blob proto); released at teardown.
_file_lists: std.ArrayList(*FileList) = .empty,
@@ -1461,12 +1439,12 @@ fn _documentIsComplete(self: *Frame) !void {
// Dispatch window.load event.
const window_target = self.window.asEventTarget();
- if (self._event_manager.hasDirectListeners(window_target, "load", self.window._on_load)) {
+ if (self._event_manager.hasDirectListeners(window_target, "load")) {
const event = try Event.initTrusted(comptime .wrap("load"), .{}, self.page);
// This event is weird, it's dispatched directly on the window, but
// with the document as the target.
event._target = self.document.asEventTarget();
- try self._event_manager.dispatchDirect(window_target, event, self.window._on_load, .{ .inject_target = false, .context = "page load" });
+ try self._event_manager.dispatchDirect(window_target, event, .{ .inject_target = false, .context = "page load" });
}
self._session.notification.dispatch(.frame_loaded, &.{
@@ -1476,9 +1454,9 @@ fn _documentIsComplete(self: *Frame) !void {
.timestamp = lp.datetime.timestamp(.boot),
});
- if (self._event_manager.hasDirectListeners(window_target, "pageshow", self.window._on_pageshow)) {
+ if (self._event_manager.hasDirectListeners(window_target, "pageshow")) {
const pageshow_event = (try PageTransitionEvent.initTrusted(comptime .wrap("pageshow"), .{}, self)).asEvent();
- try self._event_manager.dispatchDirect(window_target, pageshow_event, self.window._on_pageshow, .{ .context = "page show" });
+ try self._event_manager.dispatchDirect(window_target, pageshow_event, .{ .context = "page show" });
}
if (comptime lp.IS_DEBUG) {
@@ -2562,7 +2540,7 @@ const HashChangeCallback = struct {
const frame = self.frame;
const target = frame.window.asEventTarget();
- if (!frame._event_manager.hasDirectListeners(target, "hashchange", frame.window._on_hashchange)) {
+ if (!frame._event_manager.hasDirectListeners(target, "hashchange")) {
return null;
}
@@ -2570,7 +2548,7 @@ const HashChangeCallback = struct {
.oldURL = self.old_url,
.newURL = self.new_url,
}, frame)).asEvent();
- try frame._event_manager.dispatchDirect(target, event, frame.window._on_hashchange, .{ .context = "Hash Change" });
+ try frame._event_manager.dispatchDirect(target, event, .{ .context = "Hash Change" });
return null;
}
};
@@ -2738,14 +2716,8 @@ fn dispatchQueuedEvents(self: *Frame) !void {
const element = html_element.asElement();
switch (queued.kind) {
- // hasAttributeFunction only sees handlers compiled via property
- // access; a parsed `onload="..."` attribute is compiled lazily at
- // dispatch (EventManager.getInlineHandler), so check it raw too.
.load => {
- if (has_dom_load_listener or
- html_element.hasAttributeFunction(.onload, self) or
- element.getAttributeSafe(comptime .wrap("onload")) != null)
- {
+ if (has_dom_load_listener) {
try self.fireElementEvent(element, comptime .wrap("load"));
}
},
@@ -2857,14 +2829,13 @@ pub fn dispatch(
self: *Frame,
target: *EventTarget,
event: *Event,
- handler: anytype,
comptime opts: EventManager.DispatchDirectOptions,
) !void {
- return self._event_manager.dispatchDirect(target, event, handler, opts);
+ return self._event_manager.dispatchDirect(target, event, opts);
}
-pub fn hasDirectListeners(self: *Frame, target: *EventTarget, typ: []const u8, handler: anytype) bool {
- return self._event_manager.hasDirectListeners(target, typ, handler);
+pub fn hasDirectListeners(self: *Frame, target: *EventTarget, typ: []const u8) bool {
+ return self._event_manager.hasDirectListeners(target, typ);
}
pub fn dupeSSO(self: *Frame, value: []const u8) !String {
@@ -3342,6 +3313,11 @@ pub fn attributeChange(self: *Frame, element: *Element, name: String, value: Str
self.scheduleFocusFixup() catch |err| {
log.err(.frame, "scheduleFocusFixup", .{ .err = err, .type = self._type, .url = self.url });
};
+ } else if (element.is(Element.Html)) |html| {
+ // the stored value: `value` holds a short one inline
+ html.eventHandlerAttributeChanged(name.str(), element.getAttributeSafe(name), self) catch |err| {
+ log.err(.frame, "event handler attribute", .{ .err = err, .type = self._type, .url = self.url });
+ };
}
}
@@ -3365,6 +3341,10 @@ pub fn attributeRemove(self: *Frame, element: *Element, name: String, old_value:
popover.attributeChanged(element, old_value.str(), null, self);
} else if (name.eql(comptime .wrap("style"))) {
self.styleAttributeChanged(element, null);
+ } else if (element.is(Element.Html)) |html| {
+ html.eventHandlerAttributeChanged(name.str(), null, self) catch |err| {
+ log.err(.frame, "event handler attribute", .{ .err = err, .type = self._type, .url = self.url });
+ };
}
}
diff --git a/src/browser/Session.zig b/src/browser/Session.zig
index ab3ded6dc..e83423ea7 100644
--- a/src/browser/Session.zig
+++ b/src/browser/Session.zig
@@ -358,7 +358,6 @@ fn removePageFromList(self: *Session, page: *Page) void {
fn tearDownPage(self: *Session, page: *Page) void {
self.notification.dispatch(.frame_remove, .{});
self.retire(page);
- self.navigation.onRemoveFrame();
}
// Allocate a Page in a free slot, publish it as the active page, and
@@ -993,7 +992,6 @@ pub fn commitPendingPage(self: *Session, replacement: *Page) !void {
// walkable (node_registry, inspector context group, isolated worlds). OLD
// is still the live page (index 0); its memory stays alive until step 4.
self.notification.dispatch(.frame_remove, .{});
- self.navigation.onRemoveFrame();
// Step 2: register the new page with CDP. `replacement.replaces` is still
// set, so the session still reports an in-flight nav and CDP's frameCreated
diff --git a/src/browser/frame/node_factory.zig b/src/browser/frame/node_factory.zig
index e09a2bcaa..fa3d256ba 100644
--- a/src/browser/frame/node_factory.zig
+++ b/src/browser/frame/node_factory.zig
@@ -1105,14 +1105,14 @@ fn populateElementAttributes(frame: *Frame, element: *Element, list: anytype) !v
// from cloneNode
try element._attributes.cloneFrom(list, frame);
element.noteStyleAttribute();
- return;
+ return noteEventHandlerAttributes(element, frame);
}
if (@TypeOf(list) == Parser.RebuiltAttributes) {
// from the parser, rebuilding an element in another document
try element._attributes.cloneFrom(list.list, frame);
element.noteStyleAttribute();
- return;
+ return noteEventHandlerAttributes(element, frame);
}
// from the parser
@@ -1127,9 +1127,19 @@ fn populateElementAttributes(frame: *Frame, element: *Element, list: anytype) !v
try attributes.ensureTotalCapacity(count, frame);
while (list.next()) |attr| {
const name = try parserAttributeName(frame, attr.name);
- try attributes.putNew(name, attr.value.slice(), frame);
+ _ = try attributes.putNew(name, attr.value.slice(), frame);
}
element.noteStyleAttribute();
+ try noteEventHandlerAttributes(element, frame);
+}
+
+// Register the on* attribute handlers with the event manager
+fn noteEventHandlerAttributes(element: *Element, frame: *Frame) !void {
+ const html = element.is(Element.Html) orelse return;
+ for (element._attributes.entries()) |*entry| {
+ // entry must be by-ref
+ try html.eventHandlerAttributeChanged(entry.name(), entry.value(), frame);
+ }
}
// Attributes are keyed by qualified name (no namespace model), so a prefixed
diff --git a/src/browser/global_scope.zig b/src/browser/global_scope.zig
index 9e7975ebd..dea4cd58e 100644
--- a/src/browser/global_scope.zig
+++ b/src/browser/global_scope.zig
@@ -237,17 +237,29 @@ pub const GlobalScope = union(enum) {
self: GlobalScope,
target: *EventTarget,
event: *Event,
- handler: anytype,
comptime opts: EventManagerBase.DispatchDirectOptions,
) !void {
return switch (self) {
- inline else => |g| g.dispatch(target, event, handler, opts),
+ inline else => |g| g.dispatch(target, event, opts),
};
}
- pub fn hasDirectListeners(self: GlobalScope, target: *EventTarget, typ: []const u8, handler: anytype) bool {
+ pub fn hasDirectListeners(self: GlobalScope, target: *EventTarget, typ: []const u8) bool {
return switch (self) {
- inline else => |g| g.hasDirectListeners(target, typ, handler),
+ inline else => |g| g.hasDirectListeners(target, typ),
+ };
+ }
+
+ pub fn setHandler(self: GlobalScope, target: *EventTarget, typ: []const u8, handler: ?JS.Function.Global) !void {
+ switch (self) {
+ inline else => |g| _ = try g._event_manager.setHandler(target, typ, handler),
+ }
+ }
+
+ pub fn getHandler(self: GlobalScope, target: *EventTarget, typ: []const u8) ?JS.Function.Global {
+ return switch (self) {
+ .frame => |frame| frame._event_manager.getHandler(target, typ),
+ .worker => |worker| worker._event_manager.getHandler(worker.js, target, typ),
};
}
diff --git a/src/browser/interactive.zig b/src/browser/interactive.zig
index b41de9ede..70497184e 100644
--- a/src/browser/interactive.zig
+++ b/src/browser/interactive.zig
@@ -283,7 +283,7 @@ pub const ListenerTargetMap = std.AutoHashMapUnmanaged(usize, std.ArrayList([]co
pub fn buildListenerTargetMap(frame: *Frame, arena: Allocator) !ListenerTargetMap {
var map = ListenerTargetMap{};
- // addEventListener registrations
+ // Listeners, event handlers (onclick, ...) included
var it = frame.page.event_listeners.lookup.iterator();
while (it.next()) |entry| {
for (entry.value_ptr.items) |*type_listeners| {
@@ -295,15 +295,6 @@ pub fn buildListenerTargetMap(frame: *Frame, arena: Allocator) !ListenerTargetMa
}
}
- // Inline handlers (onclick, onmousedown, etc.)
- var attr_it = frame._event_target_attr_listeners.iterator();
- while (attr_it.next()) |entry| {
- const gop = try map.getOrPut(arena, @intFromPtr(entry.key_ptr.target));
- if (!gop.found_existing) gop.value_ptr.* = .empty;
- // Strip "on" prefix to get the event type name.
- try gop.value_ptr.append(arena, @tagName(entry.key_ptr.handler)[2..]);
- }
-
return map;
}
diff --git a/src/browser/js/Execution.zig b/src/browser/js/Execution.zig
index f60792df1..73a95a6af 100644
--- a/src/browser/js/Execution.zig
+++ b/src/browser/js/Execution.zig
@@ -29,6 +29,7 @@ const std = @import("std");
const lp = @import("lightpanda");
const Value = @import("Value.zig");
+const Function = @import("Function.zig");
const Context = @import("Context.zig");
const Scheduler = @import("Scheduler.zig");
const Page = @import("../Page.zig");
@@ -174,18 +175,26 @@ pub fn dispatch(
self: *const Execution,
target: *EventTarget,
event: *Event,
- handler: anytype,
comptime opts: EventManagerBase.DispatchDirectOptions,
) !void {
- return self.js.global.dispatch(target, event, handler, opts);
+ return self.js.global.dispatch(target, event, opts);
}
pub fn reportError(self: *const Execution, err: Value) !void {
return self.js.global.reportError(err);
}
-pub fn hasDirectListeners(self: *const Execution, target: *EventTarget, typ: []const u8, handler: anytype) bool {
- return self.js.global.hasDirectListeners(target, typ, handler);
+pub fn hasDirectListeners(self: *const Execution, target: *EventTarget, typ: []const u8) bool {
+ return self.js.global.hasDirectListeners(target, typ);
+}
+
+/// Sets (or, with null, clears) the target's `on<typ>` event handler.
+pub fn setHandler(self: *const Execution, target: *EventTarget, typ: []const u8, handler: ?Function.Global) !void {
+ return self.js.global.setHandler(target, typ, handler);
+}
+
+pub fn getHandler(self: *const Execution, target: *EventTarget, typ: []const u8) ?Function.Global {
+ return self.js.global.getHandler(target, typ);
}
pub fn performance(self: *const Execution) *Performance {
diff --git a/src/browser/parser/Parser.zig b/src/browser/parser/Parser.zig
index a5ae06911..2b51ba678 100644
--- a/src/browser/parser/Parser.zig
+++ b/src/browser/parser/Parser.zig
@@ -665,8 +665,12 @@ fn _addAttrsIfMissingCallback(self: *Parser, node: *Node, attributes: h5e.Attrib
while (attributes.next()) |attr| {
const name = attr.name.local.slice();
const value = attr.value.slice();
- // putNew only adds if the attribute doesn't already exist
- try attr_list.putNew(name, value, frame);
+ if (try attr_list.putNew(name, value, frame)) {
+ // attribute didn't previously exist
+ if (element.is(Element.Html)) |html| {
+ try html.eventHandlerAttributeChanged(name, element.getAttributeSafe(.wrap(name)), frame);
+ }
+ }
}
element.noteStyleAttribute();
}
diff --git a/src/browser/tests/element/html/event_listeners.html b/src/browser/tests/element/html/event_listeners.html
index 616ebbe76..0f6df00cb 100644
--- a/src/browser/tests/element/html/event_listeners.html
+++ b/src/browser/tests/element/html/event_listeners.html
@@ -512,6 +512,235 @@
}
</script>
+<div id="order-attr" onclick="window.order.push('attr')"><span id="order-attr-child"></span></div>
+<div id="bad-attr" onclick="this is not valid js("></div>
+
+<script id="handler_order_property">
+{
+ const r = [];
+ const a = document.createElement('a');
+ a.addEventListener('click', () => r.push(1));
+ a.onclick = () => r.push(2);
+ a.addEventListener('click', () => r.push(3));
+ a.click();
+ testing.expectEqual('1,2,3', r.join());
+
+ // Replacing a non-null handler keeps its position.
+ r.length = 0;
+ a.onclick = () => r.push('b');
+ a.click();
+ testing.expectEqual('1,b,3', r.join());
+
+ // Setting it to null removes it; setting it again appends it.
+ r.length = 0;
+ a.onclick = null;
+ a.click();
+ testing.expectEqual('1,3', r.join());
+
+ r.length = 0;
+ a.onclick = () => r.push('c');
+ a.click();
+ testing.expectEqual('1,3,c', r.join());
+
+ // At the target, capture listeners run before the handler.
+ r.length = 0;
+ a.addEventListener('click', () => r.push('capture'), true);
+ a.click();
+ testing.expectEqual('capture,1,3,c', r.join());
+
+ // A non-object value clears it.
+ a.onclick = 5;
+ testing.expectEqual(null, a.onclick);
+}
+</script>
+
+<script id="handler_order_bubbling">
+{
+ const r = [];
+ const parent = document.createElement('div');
+ const child = document.createElement('span');
+ parent.appendChild(child);
+ parent.addEventListener('click', () => r.push(1));
+ parent.onclick = () => r.push(2);
+ parent.addEventListener('click', () => r.push(3));
+ child.click();
+ testing.expectEqual('1,2,3', r.join());
+}
+</script>
+
+<script id="handler_stop_immediate_propagation">
+{
+ const r = [];
+ const a = document.createElement('a');
+ a.addEventListener('click', (e) => { r.push(1); e.stopImmediatePropagation(); });
+ a.onclick = () => r.push(2);
+ a.click();
+ testing.expectEqual('1', r.join());
+}
+</script>
+
+<script id="handler_return_value">
+{
+ const a = document.createElement('a');
+ a.onclick = () => false;
+ let e = new MouseEvent('click', { cancelable: true });
+ a.dispatchEvent(e);
+ testing.expectEqual(true, e.defaultPrevented);
+
+ // Only false cancels; and not for a passive-looking undefined.
+ a.onclick = () => undefined;
+ e = new MouseEvent('click', { cancelable: true });
+ a.dispatchEvent(e);
+ testing.expectEqual(false, e.defaultPrevented);
+
+ // An element's onerror isn't special: false cancels it too.
+ const img = document.createElement('img');
+ img.onerror = () => false;
+ e = new Event('error', { cancelable: true });
+ img.dispatchEvent(e);
+ testing.expectEqual(true, e.defaultPrevented);
+}
+</script>
+
+<script id="handler_order_content_attribute">
+{
+ window.order = [];
+ const div = $('#order-attr');
+ div.addEventListener('click', () => window.order.push('listener'));
+ $('#order-attr-child').click();
+ testing.expectEqual('attr,listener', window.order.join());
+
+ // Setting the content attribute replaces the property's value, and
+ // removing it removes the handler.
+ window.order = [];
+ div.onclick = () => window.order.push('property');
+ div.setAttribute('onclick', "window.order.push('attr2')");
+ div.click();
+ testing.expectEqual('attr2,listener', window.order.join());
+
+ window.order = [];
+ div.removeAttribute('onclick');
+ testing.expectEqual(null, div.onclick);
+ div.click();
+ testing.expectEqual('listener', window.order.join());
+
+ window.order = [];
+ div.setAttribute('onclick', "window.order.push('attr3')");
+ div.click();
+ testing.expectEqual('listener,attr3', window.order.join());
+
+ // Cloning keeps the attribute's handler.
+ window.order = [];
+ const clone = div.cloneNode();
+ clone.addEventListener('click', () => window.order.push('clone listener'));
+ clone.click();
+ testing.expectEqual('attr3,clone listener', window.order.join());
+
+ // So does innerHTML.
+ window.order = [];
+ const holder = document.createElement('div');
+ holder.innerHTML = `<span onclick="window.order.push('inner')"></span>`;
+ holder.firstChild.click();
+ testing.expectEqual('inner', window.order.join());
+}
+</script>
+
+<script id="handler_content_attribute_short">
+{
+ // A short value (stored inline in a String) set from script.
+ window.short_hits = 0;
+ window.h = () => window.short_hits++;
+ const div = document.createElement('div');
+ div.setAttribute('onclick', 'h()');
+ for (let i = 0; i < 100; i++) {
+ document.createElement('span').setAttribute('data-x', 'y' + i);
+ }
+ div.click();
+ testing.expectEqual(1, window.short_hits);
+ testing.expectEqual('function', typeof div.onclick);
+}
+</script>
+
+<script id="handler_content_attribute_invalid">
+{
+ // An attribute that doesn't compile reports a SyntaxError and leaves the
+ // handler null.
+ let reported = null;
+ const onError = (e) => { reported = e.error; e.preventDefault(); };
+ window.addEventListener('error', onError);
+ const div = $('#bad-attr');
+ testing.expectEqual(null, div.onclick);
+ window.removeEventListener('error', onError);
+ testing.expectEqual(true, reported instanceof SyntaxError);
+
+ let fired = false;
+ div.addEventListener('click', () => fired = true);
+ div.click();
+ testing.expectEqual(true, fired);
+}
+</script>
+
+<script id="handler_order_document_window">
+{
+ const r = [];
+ document.addEventListener('click', () => r.push(1));
+ document.onclick = () => r.push(2);
+ document.addEventListener('click', () => r.push(3));
+ document.dispatchEvent(new Event('click'));
+ testing.expectEqual('1,2,3', r.join());
+ document.onclick = null;
+
+ r.length = 0;
+ window.addEventListener('resize', () => r.push(1));
+ window.onresize = () => r.push(2);
+ window.addEventListener('resize', () => r.push(3));
+ window.dispatchEvent(new Event('resize'));
+ testing.expectEqual('1,2,3', r.join());
+ window.onresize = null;
+}
+</script>
+
+<script id="handler_body_reflects_window">
+{
+ const r = [];
+ document.body.onresize = () => r.push('body');
+ testing.expectEqual(true, window.onresize === document.body.onresize);
+ window.dispatchEvent(new Event('resize'));
+ testing.expectEqual('body', r.join());
+
+ document.body.setAttribute('onresize', "window.resized_by_attr = true");
+ testing.expectEqual('function', typeof window.onresize);
+ window.dispatchEvent(new Event('resize'));
+ testing.expectEqual(true, window.resized_by_attr);
+ // ...and not as a handler on the body element itself.
+ testing.expectEqual('body', r.join());
+
+ document.body.removeAttribute('onresize');
+ testing.expectEqual(null, window.onresize);
+}
+</script>
+
+<script id="handler_non_node_targets">
+{
+ const r = [];
+ const xhr = new XMLHttpRequest();
+ xhr.addEventListener('load', () => r.push(1));
+ xhr.onload = () => r.push(2);
+ xhr.addEventListener('load', () => r.push(3));
+ xhr.dispatchEvent(new Event('load'));
+ testing.expectEqual('1,2,3', r.join());
+ xhr.onload = null;
+ testing.expectEqual(null, xhr.onload);
+
+ r.length = 0;
+ const ac = new AbortController();
+ ac.signal.addEventListener('abort', () => r.push(1));
+ ac.signal.onabort = () => r.push(2);
+ ac.abort();
+ testing.expectEqual('1,2', r.join());
+}
+</script>
+
<img src="https://cdn.lightpanda.io/website/assets/images/docs/hn.png" />
<script id="document-element-load" type=module>
diff --git a/src/browser/tests/frames/cross_realm_listeners.html b/src/browser/tests/frames/cross_realm_listeners.html
index 1d6c2b85e..f0fc3b33e 100644
--- a/src/browser/tests/frames/cross_realm_listeners.html
+++ b/src/browser/tests/frames/cross_realm_listeners.html
@@ -18,6 +18,46 @@
});
</script>
+<script id=parent_handler_on_child_node>
+ testing.onload(() => {
+ const cw = $('#f1').contentWindow;
+ const child_body = cw.document.body;
+
+ // The parent's event handler on a child node, dispatched from the
+ // child's realm.
+ let fired = 0;
+ child_body.onclick = () => fired += 1;
+ cw.HTMLElement.prototype.click.call(child_body);
+ testing.expectEqual(1, fired);
+ testing.expectEqual('function', typeof child_body.onclick);
+
+ child_body.onclick = null;
+ cw.HTMLElement.prototype.click.call(child_body);
+ testing.expectEqual(1, fired);
+ });
+</script>
+
+<iframe id=f_srcdoc srcdoc="<body>child</body>"></iframe>
+
+<script id=parent_reads_child_window_attribute_handler>
+ testing.onload(() => {
+ const cw = $('#f_srcdoc').contentWindow;
+ const parent_title = document.title;
+
+ // The child's body attribute is the child Window's handler; the parent's
+ // getter compiling it must compile it in the child's realm.
+ cw.document.body.setAttribute('onload', "document.title = 'from child handler'");
+ const desc = Object.getOwnPropertyDescriptor(window, 'onload') ??
+ Object.getOwnPropertyDescriptor(Window.prototype, 'onload');
+ const handler = desc.get.call(cw);
+ testing.expectEqual('function', typeof handler);
+ handler();
+ testing.expectEqual('from child handler', cw.document.title);
+ testing.expectEqual(parent_title, document.title);
+ cw.document.body.removeAttribute('onload');
+ });
+</script>
+
<script id=child_realm_add_on_parent_node>
testing.onload(() => {
const cw = $('#f1').contentWindow;
diff --git a/src/browser/webapi/AbortSignal.zig b/src/browser/webapi/AbortSignal.zig
index a70cb4cd1..1a1d7209e 100644
--- a/src/browser/webapi/AbortSignal.zig
+++ b/src/browser/webapi/AbortSignal.zig
@@ -76,7 +76,6 @@ _type: Type = .generic,
_aborted: bool = false,
_is_dependent: bool = false,
_reason: Reason = .undefined,
-_on_abort: ?js.Function.Global = null,
_dependents: std.ArrayList(Dependend) = .empty,
_source_signals: std.ArrayList(*AbortSignal) = .empty,
@@ -99,14 +98,6 @@ fn getReason(self: *const AbortSignal) Reason {
return self._reason;
}
-fn getOnAbort(self: *const AbortSignal) ?js.Function.Global {
- return self._on_abort;
-}
-
-fn setOnAbort(self: *AbortSignal, cb: ?js.Function.Global) !void {
- self._on_abort = cb;
-}
-
pub fn asEventTarget(self: *AbortSignal) *EventTarget {
return self._proto;
}
@@ -176,10 +167,9 @@ pub fn removeDependent(self: *AbortSignal, dep: Dependend) void {
fn dispatchAbortEvent(self: *AbortSignal, exec: *const Execution) !void {
const target = self.asEventTarget();
- const on_abort = self._on_abort;
- if (exec.hasDirectListeners(target, "abort", on_abort)) {
+ if (exec.hasDirectListeners(target, "abort")) {
const event = try Event.initTrusted(comptime .wrap("abort"), .{}, exec.page);
- try exec.dispatch(target, event, on_abort, .{ .context = "abort signal" });
+ try exec.dispatch(target, event, .{ .context = "abort signal" });
}
}
@@ -339,7 +329,7 @@ pub const JsApi = struct {
pub const aborted = bridge.accessor(AbortSignal.getAborted, null, .{});
pub const reason = bridge.accessor(AbortSignal.getReason, null, .{});
- pub const onabort = bridge.accessor(AbortSignal.getOnAbort, AbortSignal.setOnAbort, .{});
+ pub const onabort = EventTarget.handlerAccessor(AbortSignal, "abort");
pub const throwIfAborted = bridge.function(AbortSignal.throwIfAborted, .{});
// Static method
diff --git a/src/browser/webapi/BroadcastChannel.zig b/src/browser/webapi/BroadcastChannel.zig
index 0b956c77d..79a1ac395 100644
--- a/src/browser/webapi/BroadcastChannel.zig
+++ b/src/browser/webapi/BroadcastChannel.zig
@@ -36,8 +36,6 @@ _exec: *Execution,
_name: lp.String,
_sequence: u64,
_closed: bool = false,
-_on_message: ?js.Function.Global = null,
-_on_message_error: ?js.Function.Global = null,
// Intrusive node, registered in `frame._broadcast_channels` (or WGS)
// for the lifetime of the channel (until close()). The registry is how a
@@ -115,22 +113,6 @@ pub fn close(self: *BroadcastChannel) void {
self._exec.getBroadcastChannels().remove(&self._node);
}
-fn getOnMessage(self: *const BroadcastChannel) ?js.Function.Global {
- return self._on_message;
-}
-
-fn setOnMessage(self: *BroadcastChannel, cb: ?js.Function.Global) !void {
- self._on_message = cb;
-}
-
-fn getOnMessageError(self: *const BroadcastChannel) ?js.Function.Global {
- return self._on_message_error;
-}
-
-fn setOnMessageError(self: *BroadcastChannel, cb: ?js.Function.Global) !void {
- self._on_message_error = cb;
-}
-
const PostMessageCallback = struct {
sender: *BroadcastChannel,
// A self-owned structured-clone snapshot of the posted message. Re-cloned
@@ -208,7 +190,7 @@ const PostMessageCallback = struct {
}
const target = channel.asEventTarget();
- if (!exec.hasDirectListeners(target, "message", channel._on_message)) {
+ if (!exec.hasDirectListeners(target, "message")) {
continue;
}
@@ -237,7 +219,7 @@ const PostMessageCallback = struct {
continue;
}).asEvent();
- exec.dispatch(target, event, channel._on_message, .{ .context = "BroadcastChannel message" }) catch |err| {
+ exec.dispatch(target, event, .{ .context = "BroadcastChannel message" }) catch |err| {
log.debug(.dom, "BroadcastChannel.postMessage", .{ .err = err });
};
}
@@ -262,8 +244,8 @@ pub const JsApi = struct {
pub const postMessage = bridge.function(BroadcastChannel.postMessage, .{});
pub const close = bridge.function(BroadcastChannel.close, .{});
- pub const onmessage = bridge.accessor(BroadcastChannel.getOnMessage, BroadcastChannel.setOnMessage, .{});
- pub const onmessageerror = bridge.accessor(BroadcastChannel.getOnMessageError, BroadcastChannel.setOnMessageError, .{});
+ pub const onmessage = EventTarget.handlerAccessor(BroadcastChannel, "message");
+ pub const onmessageerror = EventTarget.handlerAccessor(BroadcastChannel, "messageerror");
};
const testing = @import("../../testing.zig");
diff --git a/src/browser/webapi/DedicatedWorkerGlobalScope.zig b/src/browser/webapi/DedicatedWorkerGlobalScope.zig
index a8318c1e7..f8a330be2 100644
--- a/src/browser/webapi/DedicatedWorkerGlobalScope.zig
+++ b/src/browser/webapi/DedicatedWorkerGlobalScope.zig
@@ -28,6 +28,7 @@ const lp = @import("lightpanda");
const js = @import("../js/js.zig");
+const EventTarget = @import("EventTarget.zig");
const Worker = @import("Worker.zig");
const WorkerGlobalScope = @import("WorkerGlobalScope.zig");
@@ -40,8 +41,6 @@ pub const Proto = WorkerGlobalScope;
_proto: *WorkerGlobalScope,
_worker: *Worker,
_closed: bool = false,
-_on_message: ?js.Function.Global = null,
-_on_messageerror: ?js.Function.Global = null,
// Messages received before the worker script finished evaluating. Per the
// HTML spec, postMessage'd data is buffered while the worker is loading
@@ -86,22 +85,6 @@ pub fn close(self: *DedicatedWorkerGlobalScope) void {
self._closed = true;
}
-fn getOnMessage(self: *const DedicatedWorkerGlobalScope) ?js.Function.Global {
- return self._on_message;
-}
-
-fn setOnMessage(self: *DedicatedWorkerGlobalScope, setter: ?WorkerGlobalScope.FunctionSetter) void {
- self._on_message = WorkerGlobalScope.getFunctionFromSetter(setter);
-}
-
-fn getOnMessageError(self: *const DedicatedWorkerGlobalScope) ?js.Function.Global {
- return self._on_messageerror;
-}
-
-fn setOnMessageError(self: *DedicatedWorkerGlobalScope, setter: ?WorkerGlobalScope.FunctionSetter) void {
- self._on_messageerror = WorkerGlobalScope.getFunctionFromSetter(setter);
-}
-
pub fn requestAnimationFrame(self: *DedicatedWorkerGlobalScope, cb: js.Function.Global, exec: *js.Execution) !u32 {
return self._proto._timers.schedule(exec, cb, 5, .{
.repeat = false,
@@ -206,22 +189,19 @@ const ReceiveMessageCallback = struct {
// If data is null, structured clone failed - fire messageerror
if (self.data == null) {
- const on_messageerror = worker_scope._on_messageerror;
- if (!wsg._event_manager.hasDirectListeners(target, "messageerror", on_messageerror)) {
+ if (!wsg._event_manager.hasDirectListeners(target, "messageerror")) {
return null;
}
const event = (try MessageEvent.initTrusted(comptime .wrap("messageerror"), .{
.bubbles = false,
.cancelable = false,
}, wsg.page)).asEvent();
- try wsg.dispatch(target, event, on_messageerror, .{});
+ try wsg.dispatch(target, event, .{});
return null;
}
- const on_message = worker_scope._on_message;
-
// Check if there are any listeners before creating the event
- if (!wsg._event_manager.hasDirectListeners(target, "message", on_message)) {
+ if (!wsg._event_manager.hasDirectListeners(target, "message")) {
self.data.?.release();
return null;
}
@@ -231,11 +211,15 @@ const ReceiveMessageCallback = struct {
.bubbles = false,
.cancelable = false,
}, wsg.page)).asEvent();
- try wsg.dispatch(target, event, on_message, .{});
+ try wsg.dispatch(target, event, .{});
return null;
}
};
+pub fn asEventTarget(self: *DedicatedWorkerGlobalScope) *EventTarget {
+ return self._proto.asEventTarget();
+}
+
pub const JsApi = struct {
pub const bridge = js.Bridge(DedicatedWorkerGlobalScope);
@@ -247,8 +231,8 @@ pub const JsApi = struct {
pub const postMessage = bridge.function(DedicatedWorkerGlobalScope.postMessage, .{});
pub const close = bridge.function(DedicatedWorkerGlobalScope.close, .{});
- pub const onmessage = bridge.accessor(DedicatedWorkerGlobalScope.getOnMessage, DedicatedWorkerGlobalScope.setOnMessage, .{});
- pub const onmessageerror = bridge.accessor(DedicatedWorkerGlobalScope.getOnMessageError, DedicatedWorkerGlobalScope.setOnMessageError, .{});
+ pub const onmessage = EventTarget.handlerAccessor(DedicatedWorkerGlobalScope, "message");
+ pub const onmessageerror = EventTarget.handlerAccessor(DedicatedWorkerGlobalScope, "messageerror");
pub const requestAnimationFrame = bridge.function(DedicatedWorkerGlobalScope.requestAnimationFrame, .{});
pub const cancelAnimationFrame = bridge.function(DedicatedWorkerGlobalScope.cancelAnimationFrame, .{});
};
diff --git a/src/browser/webapi/Document.zig b/src/browser/webapi/Document.zig
index e53945467..0691a763c 100644
--- a/src/browser/webapi/Document.zig
+++ b/src/browser/webapi/Document.zig
@@ -22,6 +22,7 @@ const lp = @import("lightpanda");
const idna = @import("../../sys/idna.zig");
const public_suffix_list = @import("../../data/public_suffix_list.zig");
+const EventTarget = @import("EventTarget.zig");
const URL = @import("../URL.zig");
const js = @import("../js/js.zig");
const Page = @import("../Page.zig");
@@ -98,36 +99,6 @@ _open_popovers: std.ArrayList(*Element) = .empty,
// document.open/close/write/writeln must throw InvalidStateError.
_throw_on_dynamic_markup_insertion_counter: u32 = 0,
-_on_selectionchange: ?js.Function.Global = null,
-
-fn getOnSelectionChange(self: *Document) ?js.Function.Global {
- return self._on_selectionchange;
-}
-
-fn setOnSelectionChange(self: *Document, listener: ?js.Function) !void {
- if (listener) |listen| {
- self._on_selectionchange = try listen.persistWithThis(self);
- } else {
- self._on_selectionchange = null;
- }
-}
-
-// Stored in the frame's attribute-listener map (like element and ShadowRoot
-// property handlers), which the dispatch propagation path consults for any
-// event target.
-fn getOnClick(self: *Document, frame: *Frame) ?js.Function.Global {
- return (self._frame orelse frame)._event_target_attr_listeners.get(.{ .target = self.asEventTarget(), .handler = .onclick });
-}
-
-fn setOnClick(self: *Document, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- const owner = self._frame orelse frame;
- if (Window.getFunctionFromSetter(setter)) |cb| {
- try owner._event_target_attr_listeners.put(owner.page_arena, .{ .target = self.asEventTarget(), .handler = .onclick }, cb);
- } else {
- _ = owner._event_target_attr_listeners.remove(.{ .target = self.asEventTarget(), .handler = .onclick });
- }
-}
-
pub const Type = union(enum) {
generic,
html: *HTMLDocument,
@@ -159,7 +130,7 @@ pub fn asNode(self: *Document) *Node {
return self._proto;
}
-pub fn asEventTarget(self: *Document) *@import("EventTarget.zig") {
+pub fn asEventTarget(self: *Document) *EventTarget {
return self._proto.asEventTarget();
}
@@ -1653,12 +1624,12 @@ pub const JsApi = struct {
return Sanitizer.parseHTML(html, options, false, frame);
}
- pub const onselectionchange = bridge.accessor(Document.getOnSelectionChange, Document.setOnSelectionChange, .{});
- pub const onclick = bridge.accessor(Document.getOnClick, Document.setOnClick, .{});
- pub const ontouchstart = bridge.accessor(handlerAccessor(.ontouchstart).get, handlerAccessor(.ontouchstart).set, .{});
- pub const ontouchend = bridge.accessor(handlerAccessor(.ontouchend).get, handlerAccessor(.ontouchend).set, .{});
- pub const ontouchmove = bridge.accessor(handlerAccessor(.ontouchmove).get, handlerAccessor(.ontouchmove).set, .{});
- pub const ontouchcancel = bridge.accessor(handlerAccessor(.ontouchcancel).get, handlerAccessor(.ontouchcancel).set, .{});
+ pub const onselectionchange = EventTarget.handlerAccessor(Document, "selectionchange");
+ pub const onclick = EventTarget.handlerAccessor(Document, "click");
+ pub const ontouchstart = EventTarget.handlerAccessor(Document, "touchstart");
+ pub const ontouchend = EventTarget.handlerAccessor(Document, "touchend");
+ pub const ontouchmove = EventTarget.handlerAccessor(Document, "touchmove");
+ pub const ontouchcancel = EventTarget.handlerAccessor(Document, "touchcancel");
pub const URL = bridge.accessor(Document.getURL, null, .{});
pub const location = bridge.accessor(Document.getLocation, Document.setLocation, .{});
pub const documentURI = bridge.accessor(Document.getURL, null, .{});
@@ -1745,26 +1716,6 @@ pub const JsApi = struct {
pub const compatMode = bridge.accessor(Document.getCompatMode, null, .{});
pub const lastModified = bridge.accessor(Document.getLastModified, null, .{});
pub const referrer = bridge.accessor(Document.getReferrer, null, .{});
-
- // Generates a getter/setter pair backed by the frame's attribute-listener
- // map, like onclick above, for other document event handler properties.
- fn handlerAccessor(comptime handler: @import("global_event_handlers.zig").Handler) type {
- return struct {
- pub fn get(self: *Document, frame: *Frame) ?js.Function.Global {
- const owner = self._frame orelse frame;
- return owner._event_target_attr_listeners.get(.{ .target = self.asEventTarget(), .handler = handler });
- }
-
- pub fn set(self: *Document, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- const owner = self._frame orelse frame;
- if (Window.getFunctionFromSetter(setter)) |cb| {
- try owner._event_target_attr_listeners.put(owner.page_arena, .{ .target = self.asEventTarget(), .handler = handler }, cb);
- } else {
- _ = owner._event_target_attr_listeners.remove(.{ .target = self.asEventTarget(), .handler = handler });
- }
- }
- };
- }
};
const testing = @import("../../testing.zig");
diff --git a/src/browser/webapi/EventTarget.zig b/src/browser/webapi/EventTarget.zig
index a2714197b..84640b9af 100644
--- a/src/browser/webapi/EventTarget.zig
+++ b/src/browser/webapi/EventTarget.zig
@@ -67,11 +67,7 @@ const EventTarget = @This();
pub const _prototype_root = true;
-// `global_event_handlers.Key` reuses the low 3 bits of an EventTarget pointer,
-// so the type has to stay 8-byte aligned even though the tag is a single byte.
-// This costs nothing in a chain: EventTarget is always at offset 0 and every
-// subtype that follows it is itself 8-aligned.
-_type: Type align(8),
+_type: Type,
pub const Type = enum(u8) {
abort_signal,
@@ -206,11 +202,37 @@ pub fn dispatchEvent(self: *EventTarget, event: *Event, exec: *js.Execution) !bo
defer _ = event.releaseRef(frame.page);
try frame._event_manager.dispatch(self, event);
},
- .worker => |wgs| try wgs.dispatch(self, event, null, .{}),
+ .worker => |wgs| try wgs.dispatch(self, event, .{}),
}
return !event._cancelable or !event._prevent_default;
}
+pub const HandlerValue = union(enum) {
+ func: js.Function.Global,
+ anything: js.Value, // accept anything and when not callable, sets to null
+
+ pub fn function(value: ?HandlerValue) ?js.Function.Global {
+ return switch (value orelse return null) {
+ .func => |func| func,
+ .anything => null,
+ };
+ }
+};
+
+// Create a get and set accessor for on* handlers
+pub fn handlerAccessor(comptime T: type, comptime typ: []const u8) js.bridge.Accessor {
+ const H = struct {
+ fn get(self: *T, exec: *js.Execution) ?js.Function.Global {
+ return exec.getHandler(self.asEventTarget(), typ);
+ }
+
+ fn set(self: *T, value: ?HandlerValue, exec: *js.Execution) !void {
+ return exec.setHandler(self.asEventTarget(), typ, HandlerValue.function(value));
+ }
+ };
+ return js.Bridge(T).accessor(H.get, H.set, .{});
+}
+
const AddEventListenerOptions = union(enum) {
capture: bool,
options: Options,
@@ -422,8 +444,7 @@ test "WebApi: EventTarget" {
testing.silenceLog(&.{ .js, .event });
// we create thousands of these per frame. Nothing should bloat it.
- // The tag is 1 byte; the rest is the align(8) that `Key.fuse` depends on.
- try testing.expectEqual(8, @sizeOf(EventTarget));
- try testing.expectEqual(8, @alignOf(EventTarget));
+ // (fine to go up to 8, since it'll always be padded to that)
+ try testing.expectEqual(1, @sizeOf(EventTarget));
try testing.htmlRunner("events.html", .{});
}
diff --git a/src/browser/webapi/FileReader.zig b/src/browser/webapi/FileReader.zig
index e03dbf273..415689123 100644
--- a/src/browser/webapi/FileReader.zig
+++ b/src/browser/webapi/FileReader.zig
@@ -48,13 +48,6 @@ _ready_state: ReadyState = .empty,
_result: ?Result = null,
_error: ?[]const u8 = null,
-_on_abort: ?js.Function.Global = null,
-_on_error: ?js.Function.Global = null,
-_on_load: ?js.Function.Global = null,
-_on_load_end: ?js.Function.Global = null,
-_on_load_start: ?js.Function.Global = null,
-_on_progress: ?js.Function.Global = null,
-
const ReadyState = enum(u8) {
empty = 0,
loading = 1,
@@ -79,13 +72,6 @@ pub fn init(exec: *Execution) !*FileReader {
}
pub fn deinit(self: *FileReader, page: *Page) void {
- if (self._on_abort) |func| func.release();
- if (self._on_error) |func| func.release();
- if (self._on_load) |func| func.release();
- if (self._on_load_end) |func| func.release();
- if (self._on_load_start) |func| func.release();
- if (self._on_progress) |func| func.release();
-
page.event_listeners.removeTarget(self.asEventTarget());
self._arena.release();
}
@@ -98,58 +84,10 @@ pub fn acquireRef(self: *FileReader) void {
self._rc.acquire();
}
-fn asEventTarget(self: *FileReader) *EventTarget {
+pub fn asEventTarget(self: *FileReader) *EventTarget {
return self._proto;
}
-fn getOnAbort(self: *const FileReader) ?js.Function.Global {
- return self._on_abort;
-}
-
-fn setOnAbort(self: *FileReader, cb: ?js.Function.Global) !void {
- self._on_abort = cb;
-}
-
-fn getOnError(self: *const FileReader) ?js.Function.Global {
- return self._on_error;
-}
-
-fn setOnError(self: *FileReader, cb: ?js.Function.Global) !void {
- self._on_error = cb;
-}
-
-fn getOnLoad(self: *const FileReader) ?js.Function.Global {
- return self._on_load;
-}
-
-fn setOnLoad(self: *FileReader, cb: ?js.Function.Global) !void {
- self._on_load = cb;
-}
-
-fn getOnLoadEnd(self: *const FileReader) ?js.Function.Global {
- return self._on_load_end;
-}
-
-fn setOnLoadEnd(self: *FileReader, cb: ?js.Function.Global) !void {
- self._on_load_end = cb;
-}
-
-fn getOnLoadStart(self: *const FileReader) ?js.Function.Global {
- return self._on_load_start;
-}
-
-fn setOnLoadStart(self: *FileReader, cb: ?js.Function.Global) !void {
- self._on_load_start = cb;
-}
-
-fn getOnProgress(self: *const FileReader) ?js.Function.Global {
- return self._on_progress;
-}
-
-fn setOnProgress(self: *FileReader, cb: ?js.Function.Global) !void {
- self._on_progress = cb;
-}
-
fn getReadyState(self: *const FileReader) u8 {
return @backingInt(self._ready_state);
}
@@ -384,15 +322,13 @@ pub fn abort(self: *FileReader) !void {
}
fn dispatch(self: *FileReader, comptime event_type: DispatchType, progress_: ?Progress, exec: *Execution) !void {
- const field, const typ = comptime blk: {
- break :blk switch (event_type) {
- .abort => .{ "_on_abort", "abort" },
- .err => .{ "_on_error", "error" },
- .load => .{ "_on_load", "load" },
- .load_end => .{ "_on_load_end", "loadend" },
- .load_start => .{ "_on_load_start", "loadstart" },
- .progress => .{ "_on_progress", "progress" },
- };
+ const typ = comptime switch (event_type) {
+ .abort => "abort",
+ .err => "error",
+ .load => "load",
+ .load_end => "loadend",
+ .load_start => "loadstart",
+ .progress => "progress",
};
const progress = progress_ orelse Progress{};
@@ -405,7 +341,6 @@ fn dispatch(self: *FileReader, comptime event_type: DispatchType, progress_: ?Pr
return exec.dispatch(
self.asEventTarget(),
event,
- @field(self, field),
.{ .context = "FileReader " ++ typ },
);
}
@@ -477,12 +412,12 @@ pub const JsApi = struct {
pub const @"error" = bridge.accessor(FileReader.getError, null, .{});
// Event handlers
- pub const onabort = bridge.accessor(FileReader.getOnAbort, FileReader.setOnAbort, .{});
- pub const onerror = bridge.accessor(FileReader.getOnError, FileReader.setOnError, .{});
- pub const onload = bridge.accessor(FileReader.getOnLoad, FileReader.setOnLoad, .{});
- pub const onloadend = bridge.accessor(FileReader.getOnLoadEnd, FileReader.setOnLoadEnd, .{});
- pub const onloadstart = bridge.accessor(FileReader.getOnLoadStart, FileReader.setOnLoadStart, .{});
- pub const onprogress = bridge.accessor(FileReader.getOnProgress, FileReader.setOnProgress, .{});
+ pub const onabort = EventTarget.handlerAccessor(FileReader, "abort");
+ pub const onerror = EventTarget.handlerAccessor(FileReader, "error");
+ pub const onload = EventTarget.handlerAccessor(FileReader, "load");
+ pub const onloadend = EventTarget.handlerAccessor(FileReader, "loadend");
+ pub const onloadstart = EventTarget.handlerAccessor(FileReader, "loadstart");
+ pub const onprogress = EventTarget.handlerAccessor(FileReader, "progress");
// Methods
pub const readAsArrayBuffer = bridge.function(FileReader.readAsArrayBuffer, .{});
diff --git a/src/browser/webapi/History.zig b/src/browser/webapi/History.zig
index 45d324fb3..58f1d3de5 100644
--- a/src/browser/webapi/History.zig
+++ b/src/browser/webapi/History.zig
@@ -117,9 +117,9 @@ fn goInner(delta: i32, frame: *Frame) !void {
if (same_document) {
const target = frame.window.asEventTarget();
- if (frame._event_manager.hasDirectListeners(target, "popstate", frame.window._on_popstate)) {
+ if (frame._event_manager.hasDirectListeners(target, "popstate")) {
const event = (try PopStateEvent.initTrusted(comptime .wrap("popstate"), .{ .state = entry._state.value }, frame)).asEvent();
- try frame._event_manager.dispatchDirect(target, event, frame.window._on_popstate, .{ .context = "Pop State" });
+ try frame._event_manager.dispatchDirect(target, event, .{ .context = "Pop State" });
}
// hashchange is queued by navigateInner.
}
diff --git a/src/browser/webapi/MessagePort.zig b/src/browser/webapi/MessagePort.zig
index 6ae7b7e56..1e6c9df9d 100644
--- a/src/browser/webapi/MessagePort.zig
+++ b/src/browser/webapi/MessagePort.zig
@@ -38,8 +38,6 @@ _proto: *EventTarget,
_exec: *Execution,
_enabled: bool = false,
_closed: bool = false,
-_on_message: ?js.Function.Global = null,
-_on_message_error: ?js.Function.Global = null,
_entangled_port: ?*MessagePort = null,
// queued message received before the port is started.
@@ -142,25 +140,6 @@ pub fn close(self: *MessagePort) void {
self._entangled_port = null;
}
-fn getOnMessage(self: *const MessagePort) ?js.Function.Global {
- return self._on_message;
-}
-
-fn setOnMessage(self: *MessagePort, cb: ?js.Function.Global) !void {
- self._on_message = cb;
- if (cb != null) {
- self.start();
- }
-}
-
-fn getOnMessageError(self: *const MessagePort) ?js.Function.Global {
- return self._on_message_error;
-}
-
-fn setOnMessageError(self: *MessagePort, cb: ?js.Function.Global) !void {
- self._on_message_error = cb;
-}
-
// Queues delivery of `message` (a clone already living in this port's
// context) on this port's scheduler.
fn scheduleDelivery(self: *MessagePort, message: js.Value.Global) !void {
@@ -208,7 +187,7 @@ const DeliverCallback = struct {
}
const target = port.asEventTarget();
- if (!exec.hasDirectListeners(target, "message", port._on_message)) {
+ if (!exec.hasDirectListeners(target, "message")) {
self.message.release();
return null;
}
@@ -223,7 +202,7 @@ const DeliverCallback = struct {
return null;
}).asEvent();
- exec.dispatch(target, event, port._on_message, .{ .context = "MessagePort message" }) catch |err| {
+ exec.dispatch(target, event, .{ .context = "MessagePort message" }) catch |err| {
log.debug(.dom, "MessagePort.postMessage", .{ .err = err });
};
@@ -231,6 +210,19 @@ const DeliverCallback = struct {
}
};
+fn getOnMessage(self: *MessagePort, exec: *js.Execution) ?js.Function.Global {
+ return exec.getHandler(self.asEventTarget(), "message");
+}
+
+// Setting onmessage implicitly starts the port (unlike addEventListener).
+fn setOnMessage(self: *MessagePort, value: ?EventTarget.HandlerValue, exec: *js.Execution) !void {
+ const cb = EventTarget.HandlerValue.function(value);
+ try exec.setHandler(self.asEventTarget(), "message", cb);
+ if (cb != null) {
+ self.start();
+ }
+}
+
pub const JsApi = struct {
pub const bridge = js.Bridge(MessagePort);
@@ -245,5 +237,5 @@ pub const JsApi = struct {
pub const close = bridge.function(MessagePort.close, .{});
pub const onmessage = bridge.accessor(MessagePort.getOnMessage, MessagePort.setOnMessage, .{});
- pub const onmessageerror = bridge.accessor(MessagePort.getOnMessageError, MessagePort.setOnMessageError, .{});
+ pub const onmessageerror = EventTarget.handlerAccessor(MessagePort, "messageerror");
};
diff --git a/src/browser/webapi/Performance.zig b/src/browser/webapi/Performance.zig
index 96dbf84a9..506149b98 100644
--- a/src/browser/webapi/Performance.zig
+++ b/src/browser/webapi/Performance.zig
@@ -64,7 +64,6 @@ _navigation: PerformanceNavigation = .{},
_event_counts: EventCounts = .{},
_resource_buffer_size: u32 = DEFAULT_RESOURCE_BUFFER_SIZE,
_buffer_full_pending: bool = false,
-_on_buffer_full: ?js.Function.Global = null,
// The owner's task scheduler and its main-world Execution, both set by the
// owner once its JS context exists (Frame builds the Window, and thus this,
@@ -614,7 +613,7 @@ fn scheduleBufferFull(self: *Performance) !void {
if (self._buffer_full_pending) {
return;
}
- if (self._exec.hasDirectListeners(self.asEventTarget(), BUFFER_FULL, self._on_buffer_full) == false) {
+ if (self._exec.hasDirectListeners(self.asEventTarget(), BUFFER_FULL) == false) {
return;
}
self._buffer_full_pending = true;
@@ -644,7 +643,7 @@ fn fireBufferFull(self: *Performance) !void {
if (self.canAddResource() == false) {
const exec = self._exec;
const event = try Event.initTrusted(.wrap(BUFFER_FULL), .{}, exec.page);
- try exec.dispatch(self.asEventTarget(), event, self._on_buffer_full, .{
+ try exec.dispatch(self.asEventTarget(), event, .{
.context = "Performance.bufferfull",
});
}
@@ -665,20 +664,6 @@ fn fireBufferFull(self: *Performance) !void {
}
}
-// The property handler for a JS-side dispatchEvent (see EventManager.dispatch).
-pub fn inlineHandler(self: *const Performance, typ: lp.String) ?js.Function.Global {
- if (typ.eql(.wrap(BUFFER_FULL))) return self._on_buffer_full;
- return null;
-}
-
-fn getOnResourceTimingBufferFull(self: *const Performance) ?js.Function.Global {
- return self._on_buffer_full;
-}
-
-fn setOnResourceTimingBufferFull(self: *Performance, cb: ?js.Function.Global) void {
- self._on_buffer_full = cb;
-}
-
pub fn scheduleDelivery(self: *Performance) !void {
if (self._delivery_scheduled) {
return;
@@ -796,7 +781,7 @@ pub const JsApi = struct {
pub const timing = bridge.accessor(Performance.getTiming, null, .{ .exposed = .window });
pub const navigation = bridge.accessor(Performance.getNavigation, null, .{ .exposed = .window });
pub const eventCounts = bridge.accessor(Performance.getEventCounts, null, .{ .exposed = .window });
- pub const onresourcetimingbufferfull = bridge.accessor(Performance.getOnResourceTimingBufferFull, Performance.setOnResourceTimingBufferFull, .{});
+ pub const onresourcetimingbufferfull = EventTarget.handlerAccessor(Performance, "resourcetimingbufferfull");
};
pub const Entry = struct {
diff --git a/src/browser/webapi/Screen.zig b/src/browser/webapi/Screen.zig
index 6b9352894..12639933d 100644
--- a/src/browser/webapi/Screen.zig
+++ b/src/browser/webapi/Screen.zig
@@ -16,8 +16,6 @@
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
-const lp = @import("lightpanda");
-
const js = @import("../js/js.zig");
const Frame = @import("../Frame.zig");
const EventTarget = @import("EventTarget.zig");
@@ -81,7 +79,6 @@ pub const Orientation = struct {
pub const Proto = EventTarget;
_proto: *EventTarget,
- _on_change: ?js.Function.Global = null,
pub fn init(frame: *Frame) !*Orientation {
return frame._factory.eventTarget(Orientation{
@@ -93,13 +90,6 @@ pub const Orientation = struct {
return self._proto;
}
- pub fn inlineHandler(self: *const Orientation, typ: lp.String) ?js.Function.Global {
- if (typ.eql(comptime .wrap("change"))) {
- return self._on_change;
- }
- return null;
- }
-
const LockType = enum {
any,
natural,
@@ -136,14 +126,6 @@ pub const Orientation = struct {
// Nothing is ever locked.
fn unlock(_: *Orientation) void {}
- fn getOnChange(self: *const Orientation) ?js.Function.Global {
- return self._on_change;
- }
-
- fn setOnChange(self: *Orientation, cb: ?js.Function.Global) void {
- self._on_change = cb;
- }
-
pub const JsApi = struct {
pub const bridge = js.Bridge(Orientation);
@@ -157,6 +139,6 @@ pub const Orientation = struct {
pub const @"type" = bridge.accessor(Orientation.getType, null, .{});
pub const lock = bridge.function(Orientation.lock, .{});
pub const unlock = bridge.function(Orientation.unlock, .{});
- pub const onchange = bridge.accessor(Orientation.getOnChange, Orientation.setOnChange, .{});
+ pub const onchange = EventTarget.handlerAccessor(Orientation, "change");
};
};
diff --git a/src/browser/webapi/ServiceWorker.zig b/src/browser/webapi/ServiceWorker.zig
index 697aaac21..7120124f4 100644
--- a/src/browser/webapi/ServiceWorker.zig
+++ b/src/browser/webapi/ServiceWorker.zig
@@ -27,7 +27,6 @@ const js = @import("../js/js.zig");
const Event = @import("Event.zig");
const EventTarget = @import("EventTarget.zig");
-const WorkerGlobalScope = @import("WorkerGlobalScope.zig");
const ServiceWorkerGlobalScope = @import("ServiceWorkerGlobalScope.zig");
const log = lp.log;
@@ -41,7 +40,6 @@ _proto: *EventTarget,
_exec: *Execution,
// Null once the scope is gone. Reports as `redundant` in that case
_scope: ?*ServiceWorkerGlobalScope,
-_on_state_change: ?js.Function.Global = null,
pub const State = enum {
parsed,
@@ -96,7 +94,7 @@ pub fn postMessage(self: *ServiceWorker, data: js.Value) !void {
pub fn stateChanged(self: *ServiceWorker) void {
const exec = self._exec;
- if (exec.hasDirectListeners(self._proto, "statechange", self._on_state_change) == false) {
+ if (exec.hasDirectListeners(self._proto, "statechange") == false) {
return;
}
@@ -119,14 +117,6 @@ fn scheduleStateChange(self: *ServiceWorker) !void {
.finalizer = StateChangeCallback.cancelled,
});
}
-pub fn getOnStateChange(self: *const ServiceWorker) ?js.Function.Global {
- return self._on_state_change;
-}
-
-pub fn setOnStateChange(self: *ServiceWorker, setter: ?WorkerGlobalScope.FunctionSetter) void {
- self._on_state_change = WorkerGlobalScope.getFunctionFromSetter(setter);
-}
-
const StateChangeCallback = struct {
arena: *lp.Arena,
worker: *ServiceWorker,
@@ -147,7 +137,7 @@ const StateChangeCallback = struct {
.cancelable = false,
}, exec.page));
- try exec.dispatch(worker._proto, event, worker._on_state_change, .{
+ try exec.dispatch(worker._proto, event, .{
.context = "ServiceWorker.statechange",
});
return null;
@@ -166,5 +156,5 @@ pub const JsApi = struct {
pub const scriptURL = bridge.accessor(ServiceWorker.getScriptURL, null, .{});
pub const state = bridge.accessor(ServiceWorker.getState, null, .{});
pub const postMessage = bridge.function(ServiceWorker.postMessage, .{});
- pub const onstatechange = bridge.accessor(ServiceWorker.getOnStateChange, ServiceWorker.setOnStateChange, .{});
+ pub const onstatechange = EventTarget.handlerAccessor(ServiceWorker, "statechange");
};
diff --git a/src/browser/webapi/ServiceWorkerGlobalScope.zig b/src/browser/webapi/ServiceWorkerGlobalScope.zig
index 419b9c89d..a347f36f5 100644
--- a/src/browser/webapi/ServiceWorkerGlobalScope.zig
+++ b/src/browser/webapi/ServiceWorkerGlobalScope.zig
@@ -22,6 +22,7 @@ const lp = @import("lightpanda");
const js = @import("../js/js.zig");
const Transfer = @import("../../network/HttpClient.zig").Transfer;
+const EventTarget = @import("EventTarget.zig");
const URL = @import("../URL.zig");
const Frame = @import("../Frame.zig");
@@ -60,9 +61,6 @@ _script_load: ?ScriptLoad = null,
_self_registration: ?*ServiceWorkerRegistration = null,
_cookie_store: ?*CookieStore = null,
-_on_install: ?js.Function.Global = null,
-_on_activate: ?js.Function.Global = null,
-_on_message: ?js.Function.Global = null,
// Our event dispatching is more complicated, because it can be held by an
// arbitrary JS promise (ExtendableEvent.waitUntil). So we create this, hold it
@@ -339,7 +337,7 @@ fn releaseScriptLoad(self: *ServiceWorkerGlobalScope) void {
fn beginInstall(self: *ServiceWorkerGlobalScope) void {
self.setState(.installing);
- self.dispatchExtendable(comptime .wrap("install"), self._on_install, struct {
+ self.dispatchExtendable(comptime .wrap("install"), struct {
fn done(ctx: *anyopaque) void {
const s: *ServiceWorkerGlobalScope = @ptrCast(@alignCast(ctx));
s.releasePendingEvent();
@@ -358,7 +356,7 @@ fn beginActivate(self: *ServiceWorkerGlobalScope) void {
return;
}
self.setState(.activating);
- self.dispatchExtendable(comptime .wrap("activate"), self._on_activate, struct {
+ self.dispatchExtendable(comptime .wrap("activate"), struct {
fn done(ctx: *anyopaque) void {
const s: *ServiceWorkerGlobalScope = @ptrCast(@alignCast(ctx));
s.releasePendingEvent();
@@ -389,7 +387,6 @@ fn finishActivation(self: *ServiceWorkerGlobalScope) void {
fn dispatchExtendable(
self: *ServiceWorkerGlobalScope,
typ: String,
- handler: ?js.Function.Global,
comptime on_done: fn (ctx: *anyopaque) void,
) !void {
const wgs = self._proto;
@@ -404,7 +401,7 @@ fn dispatchExtendable(
self._pending_event = event;
errdefer self.releasePendingEvent();
- try wgs.dispatch(wgs.asEventTarget(), base, handler, .{ .context = "service worker lifecycle" });
+ try wgs.dispatch(wgs.asEventTarget(), base, .{ .context = "service worker lifecycle" });
// Seal only after the handlers have run, so a synchronous waitUntil is
// counted before an empty pending set can complete the phase.
@@ -514,18 +511,17 @@ const ReceiveMessageCallback = struct {
const target = wgs.asEventTarget();
const data = self.data orelse {
- if (wgs._event_manager.hasDirectListeners(target, "messageerror", null)) {
+ if (wgs._event_manager.hasDirectListeners(target, "messageerror")) {
const event = (try MessageEvent.initTrusted(comptime .wrap("messageerror"), .{
.bubbles = false,
.cancelable = false,
}, wgs.page)).asEvent();
- try wgs.dispatch(target, event, null, .{});
+ try wgs.dispatch(target, event, .{});
}
return null;
};
- const on_message = self.worker_scope._on_message;
- if (wgs._event_manager.hasDirectListeners(target, "message", on_message) == false) {
+ if (wgs._event_manager.hasDirectListeners(target, "message") == false) {
data.release();
return null;
}
@@ -535,7 +531,7 @@ const ReceiveMessageCallback = struct {
.bubbles = false,
.cancelable = false,
}, wgs.page)).asEvent();
- try wgs.dispatch(target, event, on_message, .{});
+ try wgs.dispatch(target, event, .{});
return null;
}
};
@@ -575,28 +571,8 @@ pub fn skipWaiting(_: *ServiceWorkerGlobalScope, exec: *const js.Execution) !js.
return resolver.promise();
}
-pub fn getOnInstall(self: *const ServiceWorkerGlobalScope) ?js.Function.Global {
- return self._on_install;
-}
-
-pub fn setOnInstall(self: *ServiceWorkerGlobalScope, setter: ?WorkerGlobalScope.FunctionSetter) void {
- self._on_install = WorkerGlobalScope.getFunctionFromSetter(setter);
-}
-
-pub fn getOnActivate(self: *const ServiceWorkerGlobalScope) ?js.Function.Global {
- return self._on_activate;
-}
-
-pub fn setOnActivate(self: *ServiceWorkerGlobalScope, setter: ?WorkerGlobalScope.FunctionSetter) void {
- self._on_activate = WorkerGlobalScope.getFunctionFromSetter(setter);
-}
-
-pub fn getOnMessage(self: *const ServiceWorkerGlobalScope) ?js.Function.Global {
- return self._on_message;
-}
-
-pub fn setOnMessage(self: *ServiceWorkerGlobalScope, setter: ?WorkerGlobalScope.FunctionSetter) void {
- self._on_message = WorkerGlobalScope.getFunctionFromSetter(setter);
+pub fn asEventTarget(self: *ServiceWorkerGlobalScope) *EventTarget {
+ return self._proto.asEventTarget();
}
pub const JsApi = struct {
@@ -613,9 +589,9 @@ pub const JsApi = struct {
pub const skipWaiting = bridge.function(ServiceWorkerGlobalScope.skipWaiting, .{});
pub const cookieStore = bridge.accessor(ServiceWorkerGlobalScope.getCookieStore, null, .{});
- pub const oninstall = bridge.accessor(ServiceWorkerGlobalScope.getOnInstall, ServiceWorkerGlobalScope.setOnInstall, .{});
- pub const onactivate = bridge.accessor(ServiceWorkerGlobalScope.getOnActivate, ServiceWorkerGlobalScope.setOnActivate, .{});
- pub const onmessage = bridge.accessor(ServiceWorkerGlobalScope.getOnMessage, ServiceWorkerGlobalScope.setOnMessage, .{});
+ pub const oninstall = EventTarget.handlerAccessor(ServiceWorkerGlobalScope, "install");
+ pub const onactivate = EventTarget.handlerAccessor(ServiceWorkerGlobalScope, "activate");
+ pub const onmessage = EventTarget.handlerAccessor(ServiceWorkerGlobalScope, "message");
// Deliberately absent: `onfetch` and `clients`. Nothing dispatches fetch
// events yet, and an accessor that silently never fires is worse than a
diff --git a/src/browser/webapi/ServiceWorkerRegistration.zig b/src/browser/webapi/ServiceWorkerRegistration.zig
index 2eec58acf..4d59005c4 100644
--- a/src/browser/webapi/ServiceWorkerRegistration.zig
+++ b/src/browser/webapi/ServiceWorkerRegistration.zig
@@ -23,7 +23,6 @@ const js = @import("../js/js.zig");
const EventTarget = @import("EventTarget.zig");
const ServiceWorker = @import("ServiceWorker.zig");
-const WorkerGlobalScope = @import("WorkerGlobalScope.zig");
const ServiceWorkerContainer = @import("ServiceWorkerContainer.zig");
const ServiceWorkerGlobalScope = @import("ServiceWorkerGlobalScope.zig");
@@ -50,8 +49,6 @@ _container: ?*ServiceWorkerContainer,
// ServiceWorkerGlobalScope._registrations
_node: std.DoublyLinkedList.Node = .{},
-_on_update_found: ?js.Function.Global = null,
-
pub fn init(scope: *ServiceWorkerGlobalScope, container: ?*ServiceWorkerContainer, exec: *Execution) !*ServiceWorkerRegistration {
const self = try exec._factory.eventTargetWithAllocator(exec.page_arena, ServiceWorkerRegistration{
._proto = undefined,
@@ -132,14 +129,6 @@ pub fn unregister(self: *ServiceWorkerRegistration, exec: *const Execution) !js.
return resolver.promise();
}
-pub fn getOnUpdateFound(self: *const ServiceWorkerRegistration) ?js.Function.Global {
- return self._on_update_found;
-}
-
-pub fn setOnUpdateFound(self: *ServiceWorkerRegistration, setter: ?WorkerGlobalScope.FunctionSetter) void {
- self._on_update_found = WorkerGlobalScope.getFunctionFromSetter(setter);
-}
-
pub fn worker(self: *ServiceWorkerRegistration, scope: *ServiceWorkerGlobalScope) !*ServiceWorker {
if (self._worker) |w| {
return w;
@@ -165,5 +154,5 @@ pub const JsApi = struct {
pub const updateViaCache = bridge.accessor(ServiceWorkerRegistration.getUpdateViaCache, null, .{});
pub const update = bridge.function(ServiceWorkerRegistration.update, .{});
pub const unregister = bridge.function(ServiceWorkerRegistration.unregister, .{});
- pub const onupdatefound = bridge.accessor(ServiceWorkerRegistration.getOnUpdateFound, ServiceWorkerRegistration.setOnUpdateFound, .{});
+ pub const onupdatefound = EventTarget.handlerAccessor(ServiceWorkerRegistration, "updatefound");
};
diff --git a/src/browser/webapi/ShadowRoot.zig b/src/browser/webapi/ShadowRoot.zig
index 732ad587c..310c32023 100644
--- a/src/browser/webapi/ShadowRoot.zig
+++ b/src/browser/webapi/ShadowRoot.zig
@@ -20,6 +20,7 @@ const std = @import("std");
const js = @import("../js/js.zig");
const dump = @import("../dump.zig");
+const EventTarget = @import("EventTarget.zig");
const Frame = @import("../Frame.zig");
const Node = @import("Node.zig");
@@ -124,18 +125,6 @@ pub fn getHTML(self: *ShadowRoot, opts: dump.Opts.Shadow.Declarative, writer: *s
return dump.getHTML(self.asNode(), opts, writer, frame);
}
-fn getOnSlotChange(self: *ShadowRoot, frame: *Frame) ?js.Function.Global {
- return frame._event_target_attr_listeners.get(.{ .target = self.asEventTarget(), .handler = .onslotchange });
-}
-
-fn setOnSlotChange(self: *ShadowRoot, callback: ?js.Function.Global, frame: *Frame) !void {
- if (callback) |cb| {
- try frame._event_target_attr_listeners.put(frame.page_arena, .{ .target = self.asEventTarget(), .handler = .onslotchange }, cb);
- } else {
- _ = frame._event_target_attr_listeners.remove(.{ .target = self.asEventTarget(), .handler = .onslotchange });
- }
-}
-
pub fn getActiveElement(self: *ShadowRoot, frame: *Frame) ?*Element {
const root = self.asNode();
const document = root.ownerDocument(frame) orelse frame.document;
@@ -241,7 +230,7 @@ pub const JsApi = struct {
}, &buf.writer, frame);
return buf.written();
}
- pub const onslotchange = bridge.accessor(ShadowRoot.getOnSlotChange, ShadowRoot.setOnSlotChange, .{});
+ pub const onslotchange = EventTarget.handlerAccessor(ShadowRoot, "slotchange");
};
const testing = @import("../../testing.zig");
diff --git a/src/browser/webapi/SharedWorkerGlobalScope.zig b/src/browser/webapi/SharedWorkerGlobalScope.zig
index 25816d05d..7e5e861de 100644
--- a/src/browser/webapi/SharedWorkerGlobalScope.zig
+++ b/src/browser/webapi/SharedWorkerGlobalScope.zig
@@ -21,6 +21,7 @@ const lp = @import("lightpanda");
const js = @import("../js/js.zig");
+const EventTarget = @import("EventTarget.zig");
const Frame = @import("../Frame.zig");
const Transfer = @import("../../network/HttpClient.zig").Transfer;
@@ -52,8 +53,6 @@ _script_arena: ?*lp.Arena = null,
_script_buffer: std.ArrayList(u8) = .empty,
_http_transfer: ?*Transfer = null,
-_on_connect: ?js.Function.Global = null,
-
// Ports pending connnection, created before the initial script finished
_pending_connects: std.ArrayList(*MessagePort) = .empty,
@@ -182,14 +181,6 @@ pub fn close(self: *SharedWorkerGlobalScope) void {
self._closed = true;
}
-fn getOnConnect(self: *const SharedWorkerGlobalScope) ?js.Function.Global {
- return self._on_connect;
-}
-
-fn setOnConnect(self: *SharedWorkerGlobalScope, setter: ?WorkerGlobalScope.FunctionSetter) void {
- self._on_connect = WorkerGlobalScope.getFunctionFromSetter(setter);
-}
-
fn httpHeaderCallback(transfer: *Transfer) !Transfer.HeaderResult {
const self: *SharedWorkerGlobalScope = @ptrCast(@alignCast(transfer.req.ctx));
@@ -367,8 +358,7 @@ const ConnectCallback = struct {
const wgs = worker_scope._proto;
const target = wgs.asEventTarget();
- const on_connect = worker_scope._on_connect;
- if (!wgs._event_manager.hasDirectListeners(target, "connect", on_connect)) {
+ if (!wgs._event_manager.hasDirectListeners(target, "connect")) {
return null;
}
@@ -382,11 +372,15 @@ const ConnectCallback = struct {
.cancelable = false,
}, wgs.page)).asEvent();
- try wgs.dispatch(target, event, on_connect, .{ .context = "shared worker connect" });
+ try wgs.dispatch(target, event, .{ .context = "shared worker connect" });
return null;
}
};
+pub fn asEventTarget(self: *SharedWorkerGlobalScope) *EventTarget {
+ return self._proto.asEventTarget();
+}
+
pub const JsApi = struct {
pub const bridge = js.Bridge(SharedWorkerGlobalScope);
@@ -398,5 +392,5 @@ pub const JsApi = struct {
pub const name = bridge.accessor(SharedWorkerGlobalScope.getName, null, .{});
pub const close = bridge.function(SharedWorkerGlobalScope.close, .{});
- pub const onconnect = bridge.accessor(SharedWorkerGlobalScope.getOnConnect, SharedWorkerGlobalScope.setOnConnect, .{});
+ pub const onconnect = EventTarget.handlerAccessor(SharedWorkerGlobalScope, "connect");
};
diff --git a/src/browser/webapi/TaskSignal.zig b/src/browser/webapi/TaskSignal.zig
index fa452692d..bdc729358 100644
--- a/src/browser/webapi/TaskSignal.zig
+++ b/src/browser/webapi/TaskSignal.zig
@@ -33,7 +33,6 @@ pub const Proto = AbortSignal;
_proto: *AbortSignal,
_priority: Scheduler.Priority,
_priority_changing: bool = false,
-_on_prioritychange: ?js.Function.Global = null,
pub fn init(priority: Scheduler.Priority, exec: *const Execution) !*TaskSignal {
return exec._factory.taskSignal(TaskSignal{
@@ -54,14 +53,6 @@ fn getPriority(self: *const TaskSignal) Scheduler.Priority {
return self._priority;
}
-fn getOnPriorityChange(self: *const TaskSignal) ?js.Function.Global {
- return self._on_prioritychange;
-}
-
-fn setOnPriorityChange(self: *TaskSignal, cb: ?js.Function.Global) !void {
- self._on_prioritychange = cb;
-}
-
pub fn setPriority(self: *TaskSignal, priority: Scheduler.Priority, exec: *const Execution) !void {
if (self._priority_changing) {
// re-entrant priority changes (from a prioritychange listener) throw.
@@ -77,10 +68,9 @@ pub fn setPriority(self: *TaskSignal, priority: Scheduler.Priority, exec: *const
self._priority = priority;
const target = self.asEventTarget();
- const on_prioritychange = self._on_prioritychange;
- if (exec.hasDirectListeners(target, "prioritychange", on_prioritychange)) {
+ if (exec.hasDirectListeners(target, "prioritychange")) {
const event = try TaskPriorityChangeEvent.initTrusted(.{ .previousPriority = previous }, exec.page);
- try exec.dispatch(target, event.asEvent(), on_prioritychange, .{ .context = "task signal" });
+ try exec.dispatch(target, event.asEvent(), .{ .context = "task signal" });
}
}
@@ -95,5 +85,5 @@ pub const JsApi = struct {
};
pub const priority = bridge.accessor(TaskSignal.getPriority, null, .{});
- pub const onprioritychange = bridge.accessor(TaskSignal.getOnPriorityChange, TaskSignal.setOnPriorityChange, .{});
+ pub const onprioritychange = EventTarget.handlerAccessor(TaskSignal, "prioritychange");
};
diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zig
index 9ebac9f44..8fd02f2b1 100644
--- a/src/browser/webapi/Window.zig
+++ b/src/browser/webapi/Window.zig
@@ -79,18 +79,6 @@ _performance: *Performance,
_cookie_store: ?*CookieStore = null,
_idb_factory: ?*idb.IDBFactory = null,
_caches: ?*CacheStorage = null,
-_on_load: ?js.Function.Global = null,
-_on_pageshow: ?js.Function.Global = null,
-_on_popstate: ?js.Function.Global = null,
-_on_hashchange: ?js.Function.Global = null,
-_on_error: ?js.Function.Global = null,
-_on_blur: ?js.Function.Global = null,
-_on_focus: ?js.Function.Global = null,
-_on_resize: ?js.Function.Global = null,
-_on_scroll: ?js.Function.Global = null,
-_on_message: ?js.Function.Global = null,
-_on_rejection_handled: ?js.Function.Global = null,
-_on_unhandled_rejection: ?js.Function.Global = null,
_reporting_error: bool = false,
_current_event: ?*Event = null,
_location: *Location,
@@ -378,145 +366,31 @@ pub fn getCustomElements(self: *Window) *CustomElementRegistry {
return &self._custom_elements;
}
-fn getOnLoad(self: *const Window) ?js.Function.Global {
- return self._on_load;
-}
-
-fn setOnLoad(self: *Window, setter: ?FunctionSetter) void {
- self._on_load = getFunctionFromSetter(setter);
-}
-
-fn getOnPageShow(self: *const Window) ?js.Function.Global {
- return self._on_pageshow;
-}
-
-fn setOnPageShow(self: *Window, setter: ?FunctionSetter) void {
- self._on_pageshow = getFunctionFromSetter(setter);
-}
-
-fn getOnPopState(self: *const Window) ?js.Function.Global {
- return self._on_popstate;
-}
-
-fn setOnPopState(self: *Window, setter: ?FunctionSetter) void {
- self._on_popstate = getFunctionFromSetter(setter);
-}
-
-fn getOnHashChange(self: *const Window) ?js.Function.Global {
- return self._on_hashchange;
-}
-
-fn setOnHashChange(self: *Window, setter: ?FunctionSetter) void {
- self._on_hashchange = getFunctionFromSetter(setter);
-}
-
-fn getOnError(self: *const Window) ?js.Function.Global {
- return self._on_error;
-}
-
-fn setOnError(self: *Window, setter: ?FunctionSetter) void {
- self._on_error = getFunctionFromSetter(setter);
-}
-
-fn getOnBlur(self: *const Window) ?js.Function.Global {
- return self._on_blur;
-}
-
-fn setOnBlur(self: *Window, setter: ?FunctionSetter) void {
- self._on_blur = getFunctionFromSetter(setter);
-}
-
-fn getOnFocus(self: *const Window) ?js.Function.Global {
- return self._on_focus;
-}
-
-fn setOnFocus(self: *Window, setter: ?FunctionSetter) void {
- self._on_focus = getFunctionFromSetter(setter);
-}
-
-fn getOnResize(self: *const Window) ?js.Function.Global {
- return self._on_resize;
-}
-
-fn setOnResize(self: *Window, setter: ?FunctionSetter) void {
- self._on_resize = getFunctionFromSetter(setter);
-}
-
-fn getOnScroll(self: *const Window) ?js.Function.Global {
- return self._on_scroll;
-}
-
-fn setOnScroll(self: *Window, setter: ?FunctionSetter) void {
- self._on_scroll = getFunctionFromSetter(setter);
-}
-
-// Stored in the frame's attribute-listener map (like element and ShadowRoot
-// property handlers), which the dispatch propagation path consults for any
-// event target.
-fn getOnClick(self: *Window) ?js.Function.Global {
- return self._frame._event_target_attr_listeners.get(.{ .target = self.asEventTarget(), .handler = .onclick });
-}
-
-fn setOnClick(self: *Window, setter: ?FunctionSetter) !void {
- if (getFunctionFromSetter(setter)) |cb| {
- try self._frame._event_target_attr_listeners.put(self._frame.page_arena, .{ .target = self.asEventTarget(), .handler = .onclick }, cb);
- } else {
- _ = self._frame._event_target_attr_listeners.remove(.{ .target = self.asEventTarget(), .handler = .onclick });
- }
-}
-
// The "window-reflecting body element event handler set" (HTML spec): these
// event handlers of body and frameset elements are aliases for the Window's.
-// Returns the Window storage slot for the given content attribute name, or
-// null if the attribute isn't part of the set.
-fn windowReflectingHandler(self: *Window, name: lp.String) ?*?js.Function.Global {
- if (name.eql(comptime .wrap("onblur"))) return &self._on_blur;
- if (name.eql(comptime .wrap("onerror"))) return &self._on_error;
- if (name.eql(comptime .wrap("onfocus"))) return &self._on_focus;
- if (name.eql(comptime .wrap("onload"))) return &self._on_load;
- if (name.eql(comptime .wrap("onresize"))) return &self._on_resize;
- if (name.eql(comptime .wrap("onscroll"))) return &self._on_scroll;
- return null;
-}
-
-// Applies a window-reflecting content attribute (set on a body or frameset
-// element) to the Window's event handler. A null value clears the handler.
-pub fn setWindowReflectingHandlerFromAttribute(self: *Window, name: lp.String, value: ?[]const u8, frame: *Frame) void {
- const slot = self.windowReflectingHandler(name) orelse return;
- const expr = value orelse {
- slot.* = null;
- return;
- };
- if (frame.js.stringToPersistedFunction(expr, &.{"event"}, &.{})) |func| {
- slot.* = func;
- } else |err| {
- log.debug(.js, "window reflecting handler", .{ .err = err, .str = expr });
- slot.* = null;
+pub fn isWindowReflectingHandler(name: []const u8) bool {
+ inline for (.{ "onblur", "onerror", "onfocus", "onload", "onresize", "onscroll" }) |n| {
+ if (std.mem.eql(u8, name, n)) {
+ return true;
+ }
}
+ return false;
}
-fn getOnMessage(self: *const Window) ?js.Function.Global {
- return self._on_message;
-}
-
-fn setOnMessage(self: *Window, setter: ?FunctionSetter) void {
- self._on_message = getFunctionFromSetter(setter);
-}
-
-fn getOnRejectionHandled(self: *const Window) ?js.Function.Global {
- return self._on_rejection_handled;
-}
-
-fn setOnRejectionHandled(self: *Window, setter: ?FunctionSetter) void {
- self._on_rejection_handled = getFunctionFromSetter(setter);
-}
-
-fn getOnUnhandledRejection(self: *const Window) ?js.Function.Global {
- return self._on_unhandled_rejection;
-}
+// Accessor for a window-reflecting event handler (i.e. body or frameset)..
+pub fn reflectingHandlerAccessor(comptime T: type, comptime typ: []const u8) js.bridge.Accessor {
+ const H = struct {
+ fn get(self: *T, frame: *Frame) ?js.Function.Global {
+ const owner = self.asElement().ownerFrame(frame) orelse return null;
+ return owner._event_manager.getHandler(owner.window.asEventTarget(), typ);
+ }
-fn setOnUnhandledRejection(self: *Window, setter: ?FunctionSetter) void {
- self._on_unhandled_rejection = getFunctionFromSetter(setter);
+ fn set(self: *T, value: ?EventTarget.HandlerValue, frame: *Frame) !void {
+ const owner = self.asElement().ownerFrame(frame) orelse return;
+ return owner._event_manager.setHandler(owner.window.asEventTarget(), typ, EventTarget.HandlerValue.function(value));
+ }
+ };
+ return js.Bridge(T).accessor(H.get, H.set, .{});
}
pub fn fetch(_: *const Window, input: Fetch.Input, options: ?Fetch.InitOpts, exec: *const js.Execution) !js.Promise {
@@ -604,7 +478,7 @@ pub fn reportError(self: *Window, err: js.Value, frame: *Frame) !void {
const location = err.errorLocation(frame.call_arena) catch js.Value.ErrorLocation{};
const target = self.asEventTarget();
- if (!frame._event_manager.hasDirectListeners(target, "error", self._on_error)) {
+ if (!frame._event_manager.hasDirectListeners(target, "error")) {
if (comptime lp.IS_TEST == false) {
log.debug(.js, "window.reportError", .{
.message = err.toStringSlice() catch "Unknown error",
@@ -627,38 +501,12 @@ pub fn reportError(self: *Window, err: js.Value, frame: *Frame) !void {
.cancelable = true,
}, frame.page);
- // Invoke window.onerror callback if set (per WHATWG spec, this is called
- // with 5 arguments: message, source, lineno, colno, error)
- // If it returns true, the event is cancelled.
- var prevent_default = false;
- if (self._on_error) |on_error| {
- var ls: js.Local.Scope = undefined;
- frame.js.localScope(&ls);
- defer ls.deinit();
-
- const local_func = ls.toLocal(on_error);
- const result = local_func.call(js.Value, .{
- error_event._message,
- error_event._filename,
- error_event._line_number,
- error_event._column_number,
- err,
- }) catch null;
-
- // Per spec: returning true from onerror cancels the event
- if (result) |r| {
- prevent_default = r.isTrue();
- }
- }
-
const event = error_event.asEvent();
event.acquireRef();
defer event.releaseRef(frame.page);
- event._prevent_default = prevent_default;
- // Pass null as handler: onerror was already called above with 5 args.
- // We still dispatch so that addEventListener('error', ...) listeners fire.
- try frame._event_manager.dispatchDirect(target, event, null, .{
+ // window.onerror is called with the event's fields (see Listener.run).
+ try frame._event_manager.dispatchDirect(target, event, .{
.context = "window.reportError",
.run_microtasks = false,
});
@@ -1061,24 +909,19 @@ pub fn unhandledPromiseRejection(self: *Window, no_handler: bool, rejection: js.
});
}
- const event_name, const attribute_callback = blk: {
- if (no_handler) {
- break :blk .{ "unhandledrejection", self._on_unhandled_rejection };
- }
- break :blk .{ "rejectionhandled", self._on_rejection_handled };
- };
+ const event_name = if (no_handler) "unhandledrejection" else "rejectionhandled";
if (no_handler) {
frame.page.recordJsError(error.JsException);
}
const target = self.asEventTarget();
- if (frame._event_manager.hasDirectListeners(target, event_name, attribute_callback)) {
+ if (frame._event_manager.hasDirectListeners(target, event_name)) {
const event = (try @import("event/PromiseRejectionEvent.zig").init(event_name, .{
.reason = if (rejection.reason()) |r| try r.persist() else null,
.promise = try rejection.promise().persist(),
}, frame.page)).asEvent();
- try frame._event_manager.dispatchDirect(target, event, attribute_callback, .{ .context = "window.unhandledrejection" });
+ try frame._event_manager.dispatchDirect(target, event, .{ .context = "window.unhandledrejection" });
}
}
@@ -1140,7 +983,7 @@ const PostMessageCallback = struct {
// The MessageEvent takes ownership of the cloned temp and releases it on
// teardown; if there are no listeners, release it here so it doesn't leak.
- if (!frame._event_manager.hasDirectListeners(event_target, "message", window._on_message)) {
+ if (!frame._event_manager.hasDirectListeners(event_target, "message")) {
self.message.release();
return null;
}
@@ -1153,28 +996,12 @@ const PostMessageCallback = struct {
.bubbles = false,
.cancelable = false,
}, frame.page)).asEvent();
- try frame._event_manager.dispatchDirect(event_target, event, window._on_message, .{ .context = "window.postMessage" });
+ try frame._event_manager.dispatchDirect(event_target, event, .{ .context = "window.postMessage" });
return null;
}
};
-pub const FunctionSetter = union(enum) {
- func: js.Function.Global,
- anything: js.Value,
-};
-
-// window.onload = {}; doesn't fail, but it doesn't do anything.
-// seems like setting to null is ok (though, at least on Firefix, it preserves
-// the original value, which we could do, but why?)
-pub fn getFunctionFromSetter(setter_: ?FunctionSetter) ?js.Function.Global {
- const setter = setter_ orelse return null;
- return switch (setter) {
- .func => |func| func, // Already a Global from bridge auto-conversion
- .anything => null,
- };
-}
-
// Checks whether a window.open features string contains a token, matched
// case-insensitively on whole-token boundaries (comma or whitespace separated).
// The features syntax is legacy and loose; the only tokens we interpret are
@@ -1222,19 +1049,19 @@ pub const JsApi = struct {
pub const crypto = bridge.accessor(Window.getCrypto, null, .{});
pub const CSS = bridge.accessor(Window.getCSS, null, .{});
pub const customElements = bridge.accessor(Window.getCustomElements, null, .{});
- pub const onload = bridge.accessor(Window.getOnLoad, Window.setOnLoad, .{});
- pub const onpageshow = bridge.accessor(Window.getOnPageShow, Window.setOnPageShow, .{});
- pub const onpopstate = bridge.accessor(Window.getOnPopState, Window.setOnPopState, .{});
- pub const onhashchange = bridge.accessor(Window.getOnHashChange, Window.setOnHashChange, .{});
- pub const onerror = bridge.accessor(Window.getOnError, Window.setOnError, .{});
- pub const onblur = bridge.accessor(Window.getOnBlur, Window.setOnBlur, .{});
- pub const onfocus = bridge.accessor(Window.getOnFocus, Window.setOnFocus, .{});
- pub const onresize = bridge.accessor(Window.getOnResize, Window.setOnResize, .{});
- pub const onscroll = bridge.accessor(Window.getOnScroll, Window.setOnScroll, .{});
- pub const onclick = bridge.accessor(Window.getOnClick, Window.setOnClick, .{});
- pub const onmessage = bridge.accessor(Window.getOnMessage, Window.setOnMessage, .{});
- pub const onrejectionhandled = bridge.accessor(Window.getOnRejectionHandled, Window.setOnRejectionHandled, .{});
- pub const onunhandledrejection = bridge.accessor(Window.getOnUnhandledRejection, Window.setOnUnhandledRejection, .{});
+ pub const onload = EventTarget.handlerAccessor(Window, "load");
+ pub const onpageshow = EventTarget.handlerAccessor(Window, "pageshow");
+ pub const onpopstate = EventTarget.handlerAccessor(Window, "popstate");
+ pub const onhashchange = EventTarget.handlerAccessor(Window, "hashchange");
+ pub const onerror = EventTarget.handlerAccessor(Window, "error");
+ pub const onblur = EventTarget.handlerAccessor(Window, "blur");
+ pub const onfocus = EventTarget.handlerAccessor(Window, "focus");
+ pub const onresize = EventTarget.handlerAccessor(Window, "resize");
+ pub const onscroll = EventTarget.handlerAccessor(Window, "scroll");
+ pub const onclick = EventTarget.handlerAccessor(Window, "click");
+ pub const onmessage = EventTarget.handlerAccessor(Window, "message");
+ pub const onrejectionhandled = EventTarget.handlerAccessor(Window, "rejectionhandled");
+ pub const onunhandledrejection = EventTarget.handlerAccessor(Window, "unhandledrejection");
pub const event = bridge.accessor(Window.getEvent, Window.setEvent, .{ .null_as_undefined = true });
pub const fetch = bridge.function(Window.fetch, .{});
pub const queueMicrotask = bridge.function(Window.queueMicrotask, .{});
diff --git a/src/browser/webapi/Worker.zig b/src/browser/webapi/Worker.zig
index a785dd31f..1659eecde 100644
--- a/src/browser/webapi/Worker.zig
+++ b/src/browser/webapi/Worker.zig
@@ -60,9 +60,6 @@ _script_buffer: std.ArrayList(u8) = .empty,
_http_transfer: ?*Transfer = null,
// Event handlers
-_on_error: ?js.Function.Global = null,
-_on_message: ?js.Function.Global = null,
-_on_messageerror: ?js.Function.Global = null,
const WorkerOptions = struct {
type: WorkerType = .classic,
@@ -307,10 +304,8 @@ fn fireErrorEvent(self: *Worker, message: []const u8, error_value: ?js.Value.Glo
fn _fireErrorEvent(self: *Worker, message: []const u8, error_value: ?js.Value.Global) !void {
const frame = self._frame;
const target = self.asEventTarget();
- const on_error = self._on_error;
-
// Check if there are any listeners
- if (!frame._event_manager.hasDirectListeners(target, "error", on_error)) {
+ if (!frame._event_manager.hasDirectListeners(target, "error")) {
if (error_value) |ev| ev.release();
return;
}
@@ -323,7 +318,7 @@ fn _fireErrorEvent(self: *Worker, message: []const u8, error_value: ?js.Value.Gl
.cancelable = true,
}, frame.page);
- try frame._event_manager.dispatchDirect(target, error_event.asEvent(), on_error, .{
+ try frame._event_manager.dispatchDirect(target, error_event.asEvent(), .{
.context = "Worker.onerror",
});
}
@@ -370,43 +365,6 @@ pub fn receiveMessage(self: *Worker, data: js.Value) !void {
});
}
-fn getOnMessage(self: *const Worker) ?js.Function.Global {
- return self._on_message;
-}
-
-fn setOnMessage(self: *Worker, setter: ?FunctionSetter) void {
- self._on_message = getFunctionFromSetter(setter);
-}
-
-fn getOnMessageError(self: *const Worker) ?js.Function.Global {
- return self._on_messageerror;
-}
-
-fn setOnMessageError(self: *Worker, setter: ?FunctionSetter) void {
- self._on_messageerror = getFunctionFromSetter(setter);
-}
-
-fn getOnError(self: *const Worker) ?js.Function.Global {
- return self._on_error;
-}
-
-fn setOnError(self: *Worker, setter: ?FunctionSetter) void {
- self._on_error = getFunctionFromSetter(setter);
-}
-
-const FunctionSetter = union(enum) {
- func: js.Function.Global,
- anything: js.Value,
-};
-
-fn getFunctionFromSetter(setter_: ?FunctionSetter) ?js.Function.Global {
- const setter = setter_ orelse return null;
- return switch (setter) {
- .func => |func| func,
- .anything => null,
- };
-}
-
const ReceiveMessageCallback = struct {
data: anyerror!js.Value.Global,
arena: *lp.Arena,
@@ -434,8 +392,7 @@ const ReceiveMessageCallback = struct {
// If data is null, structured clone failed - fire messageerror
const data = self.data catch |err| {
- const on_messageerror = worker._on_messageerror;
- if (!frame._event_manager.hasDirectListeners(target, "messageerror", on_messageerror)) {
+ if (!frame._event_manager.hasDirectListeners(target, "messageerror")) {
return null;
}
const event = (try MessageEvent.initTrusted(comptime .wrap("messageerror"), .{
@@ -443,14 +400,12 @@ const ReceiveMessageCallback = struct {
.bubbles = false,
.cancelable = false,
}, frame.page)).asEvent();
- try frame._event_manager.dispatchDirect(target, event, on_messageerror, .{ .context = "Worker.messageerror" });
+ try frame._event_manager.dispatchDirect(target, event, .{ .context = "Worker.messageerror" });
return null;
};
- const on_message = worker._on_message;
-
// Check if there are any listeners before creating the event
- if (!frame._event_manager.hasDirectListeners(target, "message", on_message)) {
+ if (!frame._event_manager.hasDirectListeners(target, "message")) {
data.release();
return null;
}
@@ -461,7 +416,7 @@ const ReceiveMessageCallback = struct {
.cancelable = false,
}, frame.page)).asEvent();
- try frame._event_manager.dispatchDirect(target, event, on_message, .{ .context = "Worker.receiveMessage" });
+ try frame._event_manager.dispatchDirect(target, event, .{ .context = "Worker.receiveMessage" });
return null;
}
@@ -481,9 +436,9 @@ pub const JsApi = struct {
pub const terminate = bridge.function(Worker.terminate, .{});
pub const postMessage = bridge.function(Worker.postMessage, .{});
- pub const onmessage = bridge.accessor(Worker.getOnMessage, Worker.setOnMessage, .{});
- pub const onmessageerror = bridge.accessor(Worker.getOnMessageError, Worker.setOnMessageError, .{});
- pub const onerror = bridge.accessor(Worker.getOnError, Worker.setOnError, .{});
+ pub const onmessage = EventTarget.handlerAccessor(Worker, "message");
+ pub const onmessageerror = EventTarget.handlerAccessor(Worker, "messageerror");
+ pub const onerror = EventTarget.handlerAccessor(Worker, "error");
};
const testing = @import("../../testing.zig");
diff --git a/src/browser/webapi/WorkerGlobalScope.zig b/src/browser/webapi/WorkerGlobalScope.zig
index 675476646..0ae6d3d79 100644
--- a/src/browser/webapi/WorkerGlobalScope.zig
+++ b/src/browser/webapi/WorkerGlobalScope.zig
@@ -115,9 +115,6 @@ _navigator: WorkerNavigator = .init,
_performance: *Performance,
_idb_factory: ?*idb.IDBFactory = null,
_caches: ?*CacheStorage = null,
-_on_error: ?JS.Function.Global = null,
-_on_rejection_handled: ?JS.Function.Global = null,
-_on_unhandled_rejection: ?JS.Function.Global = null,
_reporting_error: bool = false,
_location: WorkerLocation,
@@ -245,22 +242,13 @@ pub fn dispatch(
self: *WorkerGlobalScope,
target: *EventTarget,
event: *Event,
- handler: anytype,
comptime opts: EventManagerBase.DispatchDirectOptions,
) !void {
- try self._event_manager.dispatchDirect(
- self.call_arena,
- self.js,
- target,
- event,
- handler,
- self.page,
- opts,
- );
+ try self._event_manager.dispatchDirect(self.js, target, event, self.page, opts);
}
-pub fn hasDirectListeners(self: *WorkerGlobalScope, target: *EventTarget, typ: []const u8, handler: anytype) bool {
- return self._event_manager.hasDirectListeners(target, typ, handler);
+pub fn hasDirectListeners(self: *WorkerGlobalScope, target: *EventTarget, typ: []const u8) bool {
+ return self._event_manager.hasDirectListeners(target, typ);
}
// Workers don't have their own Referer; per spec, dedicated worker requests
@@ -328,30 +316,6 @@ pub fn getLocation(self: *WorkerGlobalScope) *WorkerLocation {
return &self._location;
}
-fn getOnError(self: *const WorkerGlobalScope) ?JS.Function.Global {
- return self._on_error;
-}
-
-fn setOnError(self: *WorkerGlobalScope, setter: ?FunctionSetter) void {
- self._on_error = getFunctionFromSetter(setter);
-}
-
-fn getOnRejectionHandled(self: *const WorkerGlobalScope) ?JS.Function.Global {
- return self._on_rejection_handled;
-}
-
-fn setOnRejectionHandled(self: *WorkerGlobalScope, setter: ?FunctionSetter) void {
- self._on_rejection_handled = getFunctionFromSetter(setter);
-}
-
-fn getOnUnhandledRejection(self: *const WorkerGlobalScope) ?JS.Function.Global {
- return self._on_unhandled_rejection;
-}
-
-fn setOnUnhandledRejection(self: *WorkerGlobalScope, setter: ?FunctionSetter) void {
- self._on_unhandled_rejection = getFunctionFromSetter(setter);
-}
-
const base64 = @import("encoding/base64.zig");
fn btoa(_: *const WorkerGlobalScope, input: base64.BinInput, exec: *JS.Execution) ![]const u8 {
return base64.encode(exec.local_arena, input);
@@ -375,24 +339,19 @@ pub fn unhandledPromiseRejection(self: *WorkerGlobalScope, no_handler: bool, rej
});
}
- const event_name, const attribute_callback = blk: {
- if (no_handler) {
- break :blk .{ "unhandledrejection", self._on_unhandled_rejection };
- }
- break :blk .{ "rejectionhandled", self._on_rejection_handled };
- };
+ const event_name = if (no_handler) "unhandledrejection" else "rejectionhandled";
if (no_handler) {
self.page.recordJsError(error.JsException);
}
const target = self.asEventTarget();
- if (self._event_manager.hasDirectListeners(target, event_name, attribute_callback)) {
+ if (self._event_manager.hasDirectListeners(target, event_name)) {
const event = (try @import("event/PromiseRejectionEvent.zig").init(event_name, .{
.reason = if (rejection.reason()) |r| try r.persist() else null,
.promise = try rejection.promise().persist(),
}, self.page)).asEvent();
- try self.dispatch(target, event, attribute_callback, .{});
+ try self.dispatch(target, event, .{});
}
}
@@ -490,39 +449,13 @@ pub fn reportError(self: *WorkerGlobalScope, err: JS.Value) !void {
.cancelable = true,
}, self.page);
- // Invoke onerror callback if set (per WHATWG spec, this is called
- // with 5 arguments: message, source, lineno, colno, error)
- // If it returns true, the event is cancelled.
- var prevent_default = false;
- if (self._on_error) |on_error| {
- var ls: JS.Local.Scope = undefined;
- self.js.localScope(&ls);
- defer ls.deinit();
-
- const local_func = ls.toLocal(on_error);
- const result = local_func.call(JS.Value, .{
- error_event._message,
- error_event._filename,
- error_event._line_number,
- error_event._column_number,
- err,
- }) catch null;
-
- // Per spec: returning true from onerror cancels the event
- if (result) |r| {
- prevent_default = r.isTrue();
- }
- }
-
const event = error_event.asEvent();
// Keep the event alive past dispatch so we can read _prevent_default.
event.acquireRef();
defer event.releaseRef(self.page);
- event._prevent_default = prevent_default;
- // Pass null as handler: onerror was already called above with 5 args.
- // We still dispatch so that addEventListener('error', ...) listeners fire.
- try self.dispatch(self.asEventTarget(), event, null, .{});
+ // onerror is called with the event's fields (see Listener.run).
+ try self.dispatch(self.asEventTarget(), event, .{});
if (comptime lp.IS_TEST == false) {
if (!event._prevent_default) {
@@ -596,19 +529,6 @@ fn replaceGlobalProperty(self: *WorkerGlobalScope, value: JS.Value, comptime nam
_ = global.defineOwnProperty(name, value, 0);
}
-pub const FunctionSetter = union(enum) {
- func: JS.Function.Global,
- anything: JS.Value,
-};
-
-pub fn getFunctionFromSetter(setter_: ?FunctionSetter) ?JS.Function.Global {
- const setter = setter_ orelse return null;
- return switch (setter) {
- .func => |func| func,
- .anything => null,
- };
-}
-
pub const JsApi = struct {
pub const bridge = JS.Bridge(WorkerGlobalScope);
@@ -636,9 +556,9 @@ pub const JsApi = struct {
pub const indexedDB = bridge.accessor(WorkerGlobalScope.getIndexedDB, null, .{});
pub const caches = bridge.accessor(WorkerGlobalScope.getCaches, null, .{});
- pub const onerror = bridge.accessor(WorkerGlobalScope.getOnError, WorkerGlobalScope.setOnError, .{});
- pub const onrejectionhandled = bridge.accessor(WorkerGlobalScope.getOnRejectionHandled, WorkerGlobalScope.setOnRejectionHandled, .{});
- pub const onunhandledrejection = bridge.accessor(WorkerGlobalScope.getOnUnhandledRejection, WorkerGlobalScope.setOnUnhandledRejection, .{});
+ pub const onerror = EventTarget.handlerAccessor(WorkerGlobalScope, "error");
+ pub const onrejectionhandled = EventTarget.handlerAccessor(WorkerGlobalScope, "rejectionhandled");
+ pub const onunhandledrejection = EventTarget.handlerAccessor(WorkerGlobalScope, "unhandledrejection");
pub const btoa = bridge.function(WorkerGlobalScope.btoa, .{});
pub const atob = bridge.function(WorkerGlobalScope.atob, .{});
diff --git a/src/browser/webapi/animation/Animation.zig b/src/browser/webapi/animation/Animation.zig
index c658175b5..5475b0d7f 100644
--- a/src/browser/webapi/animation/Animation.zig
+++ b/src/browser/webapi/animation/Animation.zig
@@ -48,8 +48,6 @@ _timeline: ?js.Object.Global = null,
_ready_resolver: ?js.PromiseResolver.Global = null,
_finished_resolver: ?js.PromiseResolver.Global = null,
_startTime: ?f64 = null,
-_onFinish: ?js.Function.Global = null,
-_onCancel: ?js.Function.Global = null,
_playState: PlayState = .idle,
// Fake the animation by passing the states:
@@ -158,35 +156,20 @@ fn queuePlaybackEvent(self: *Animation, comptime typ: PlaybackEventType) !void {
fn run(ctx: *anyopaque) !?u32 {
const animation: *Animation = @ptrCast(@alignCast(ctx));
defer animation.releaseRef(animation._frame.page);
- const handler = switch (typ) {
- .finish => animation._onFinish,
- .cancel => animation._onCancel,
- };
- try animation.dispatchPlaybackEvent(comptime .wrap(@tagName(typ)), handler);
+ try animation.dispatchPlaybackEvent(comptime .wrap(@tagName(typ)));
return null;
}
}.run, 0, .{ .name = "animation." ++ @tagName(typ), .finalizer = Animation.cancelled });
}
-fn dispatchPlaybackEvent(self: *Animation, typ: lp.String, handler: ?js.Function.Global) !void {
+fn dispatchPlaybackEvent(self: *Animation, typ: lp.String) !void {
const frame = self._frame;
const target = self.asEventTarget();
- if (frame.hasDirectListeners(target, typ.str(), handler) == false) {
+ if (frame.hasDirectListeners(target, typ.str()) == false) {
return;
}
const event = try AnimationPlaybackEvent.initTrusted(typ, null, frame);
- return frame.dispatch(target, event.asEvent(), handler, .{ .context = "Animation" });
-}
-
-// The property handler for a JS-side dispatchEvent (see EventManager.dispatch).
-pub fn inlineHandler(self: *const Animation, typ: lp.String) ?js.Function.Global {
- if (typ.eql(comptime .wrap("finish"))) {
- return self._onFinish;
- }
- if (typ.eql(comptime .wrap("cancel"))) {
- return self._onCancel;
- }
- return null;
+ return frame.dispatch(target, event.asEvent(), .{ .context = "Animation" });
}
pub fn reverse(_: *Animation) void {
@@ -244,10 +227,6 @@ fn setStartTime(self: *Animation, value: ?f64, frame: *Frame) !void {
return self.play(frame);
}
-fn getOnFinish(self: *const Animation) ?js.Function.Global {
- return self._onFinish;
-}
-
// callback function transitioning from a state to another
fn update(ctx: *anyopaque) !?u32 {
const self: *Animation = @ptrCast(@alignCast(ctx));
@@ -266,25 +245,13 @@ fn update(ctx: *anyopaque) !?u32 {
if (self._finished_resolver) |resolver| {
ls.toLocal(resolver).resolve("Animation.getFinished", self);
}
- try self.dispatchPlaybackEvent(comptime .wrap("finish"), self._onFinish);
+ try self.dispatchPlaybackEvent(comptime .wrap("finish"));
},
.idle, .paused, .finished => {},
}
return null;
}
-fn setOnFinish(self: *Animation, cb: ?js.Function.Global) !void {
- self._onFinish = cb;
-}
-
-fn getOnCancel(self: *const Animation) ?js.Function.Global {
- return self._onCancel;
-}
-
-fn setOnCancel(self: *Animation, cb: ?js.Function.Global) !void {
- self._onCancel = cb;
-}
-
fn playState(self: *const Animation) []const u8 {
return @tagName(self._playState);
}
@@ -310,8 +277,8 @@ pub const JsApi = struct {
pub const effect = bridge.accessor(Animation.getEffect, Animation.setEffect, .{});
pub const timeline = bridge.accessor(Animation.getTimeline, Animation.setTimeline, .{});
pub const startTime = bridge.accessor(Animation.getStartTime, Animation.setStartTime, .{});
- pub const onfinish = bridge.accessor(Animation.getOnFinish, Animation.setOnFinish, .{});
- pub const oncancel = bridge.accessor(Animation.getOnCancel, Animation.setOnCancel, .{});
+ pub const onfinish = EventTarget.handlerAccessor(Animation, "finish");
+ pub const oncancel = EventTarget.handlerAccessor(Animation, "cancel");
};
const testing = @import("../../../testing.zig");
diff --git a/src/browser/webapi/css/FontFaceSet.zig b/src/browser/webapi/css/FontFaceSet.zig
index 28d58d606..e30c78465 100644
--- a/src/browser/webapi/css/FontFaceSet.zig
+++ b/src/browser/webapi/css/FontFaceSet.zig
@@ -82,15 +82,15 @@ pub fn load(self: *FontFaceSet, font: []const u8, frame: *Frame) !js.Promise {
// Dispatch loading event
const target = self.asEventTarget();
- if (frame._event_manager.hasDirectListeners(target, "loading", null)) {
+ if (frame._event_manager.hasDirectListeners(target, "loading")) {
const event = try Event.initTrusted(comptime .wrap("loading"), .{}, frame.page);
- try frame._event_manager.dispatchDirect(target, event, null, .{ .context = "load font face set" });
+ try frame._event_manager.dispatchDirect(target, event, .{ .context = "load font face set" });
}
// Dispatch loadingdone event
- if (frame._event_manager.hasDirectListeners(target, "loadingdone", null)) {
+ if (frame._event_manager.hasDirectListeners(target, "loadingdone")) {
const event = try Event.initTrusted(comptime .wrap("loadingdone"), .{}, frame.page);
- try frame._event_manager.dispatchDirect(target, event, null, .{ .context = "load font face set" });
+ try frame._event_manager.dispatchDirect(target, event, .{ .context = "load font face set" });
}
return frame.js.local.?.resolvePromise({});
diff --git a/src/browser/webapi/css/MediaQueryList.zig b/src/browser/webapi/css/MediaQueryList.zig
index 548a13776..2ca737d68 100644
--- a/src/browser/webapi/css/MediaQueryList.zig
+++ b/src/browser/webapi/css/MediaQueryList.zig
@@ -35,7 +35,6 @@ _frame: *Frame,
_media: []const u8,
// What listeners last observed; `change` fires when the viewport flips it.
_matches: bool,
-_on_change: ?js.Function.Global = null,
pub fn init(query: []const u8, frame: *Frame) !*MediaQueryList {
const media = try frame.dupeString(query);
@@ -71,7 +70,7 @@ pub fn viewportChanged(self: *MediaQueryList) void {
self._matches = matches;
const frame = self._frame;
- if (!frame.hasDirectListeners(self.asEventTarget(), "change", self._on_change)) return;
+ if (!frame.hasDirectListeners(self.asEventTarget(), "change")) return;
self.dispatchChange(matches) catch |err| {
log.debug(.browser, "matchMedia change", .{ .err = err, .media = self._media });
};
@@ -83,13 +82,7 @@ fn dispatchChange(self: *MediaQueryList, matches: bool) !void {
.matches = matches,
.media = self._media,
}, frame);
- try frame.dispatch(self.asEventTarget(), event.asEvent(), self._on_change, .{ .context = "MediaQueryList change" });
-}
-
-// The property handler for a JS-side dispatchEvent (see EventManager.dispatch).
-pub fn inlineHandler(self: *const MediaQueryList, typ: lp.String) ?js.Function.Global {
- if (typ.eql(comptime .wrap("change"))) return self._on_change;
- return null;
+ try frame.dispatch(self.asEventTarget(), event.asEvent(), .{ .context = "MediaQueryList change" });
}
pub fn addListener(self: *MediaQueryList, cb_: ?js.Function, exec: *js.Execution) !void {
@@ -102,14 +95,6 @@ pub fn removeListener(self: *MediaQueryList, cb_: ?js.Function, exec: *js.Execut
try self._proto.removeEventListener("change", .{ .value = .{ .function = cb } }, null, exec);
}
-fn getOnChange(self: *const MediaQueryList) ?js.Function.Global {
- return self._on_change;
-}
-
-fn setOnChange(self: *MediaQueryList, cb: ?js.Function.Global) void {
- self._on_change = cb;
-}
-
pub const JsApi = struct {
pub const bridge = js.Bridge(MediaQueryList);
@@ -123,7 +108,7 @@ pub const JsApi = struct {
pub const matches = bridge.accessor(MediaQueryList.getMatches, null, .{});
pub const addListener = bridge.function(MediaQueryList.addListener, .{});
pub const removeListener = bridge.function(MediaQueryList.removeListener, .{});
- pub const onchange = bridge.accessor(MediaQueryList.getOnChange, MediaQueryList.setOnChange, .{});
+ pub const onchange = EventTarget.handlerAccessor(MediaQueryList, "change");
};
const testing = @import("../../../testing.zig");
diff --git a/src/browser/webapi/element/Attribute.zig b/src/browser/webapi/element/Attribute.zig
index 01a3691e5..fb9bceecd 100644
--- a/src/browser/webapi/element/Attribute.zig
+++ b/src/browser/webapi/element/Attribute.zig
@@ -330,16 +330,17 @@ pub const List = struct {
}
// called form our parser, names already lower-cased
- pub fn putNew(self: *List, name: []const u8, value: []const u8, frame: *Frame) !void {
+ /// Whether the attribute was added.
+ pub fn putNew(self: *List, name: []const u8, value: []const u8, frame: *Frame) !bool {
if (try self.getEntry(.wrap(name), frame) != null) {
// When parsing, if there are duplicate names, it isn't valid, and
// the first is kept
- return;
+ return false;
}
const len = self._len;
if (len == std.math.maxInt(u16) or name.len > std.math.maxInt(u32) or value.len > std.math.maxInt(u32)) {
// Bad input. Drop rather than fail the parse
- return;
+ return false;
}
try self.ensureUnusedCapacity(1, frame);
@@ -348,6 +349,7 @@ pub const List = struct {
try frame.dupeString(value),
);
self._len = len + 1;
+ return true;
}
pub fn delete(self: *List, name: String, element: *Element, frame: *Frame) !void {
diff --git a/src/browser/webapi/element/Html.zig b/src/browser/webapi/element/Html.zig
index 948ba93d1..1167fb76d 100644
--- a/src/browser/webapi/element/Html.zig
+++ b/src/browser/webapi/element/Html.zig
@@ -20,16 +20,18 @@ const std = @import("std");
const lp = @import("lightpanda");
const js = @import("../../js/js.zig");
-const Factory = @import("../../Factory.zig");
-
const Frame = @import("../../Frame.zig");
+const Factory = @import("../../Factory.zig");
const StyleManager = @import("../../StyleManager.zig");
-const reflection = @import("reflection.zig");
+
const Node = @import("../Node.zig");
+const Window = @import("../Window.zig");
const Element = @import("../Element.zig");
+const EventTarget = @import("../EventTarget.zig");
const ElementInternals = @import("../ElementInternals.zig");
const global_event_handlers = @import("../global_event_handlers.zig");
+const reflection = @import("reflection.zig");
const popover = @import("popover.zig");
pub const Anchor = @import("html/Anchor.zig");
pub const Area = @import("html/Area.zig");
@@ -101,7 +103,6 @@ pub const UL = @import("html/UL.zig");
pub const Unknown = @import("html/Unknown.zig");
const log = lp.log;
-const GlobalEventHandler = global_event_handlers.Handler;
const HtmlElement = @This();
@@ -667,852 +668,24 @@ pub fn getIsContentEditable(self: *HtmlElement) bool {
return false;
}
-pub fn getAttributeFunction(
- self: *HtmlElement,
- listener_type: GlobalEventHandler,
- frame: *Frame,
-) !?js.Function.Global {
- const element = self.asElement();
- if (frame._event_target_attr_listeners.get(.{ .target = element.asEventTarget(), .handler = listener_type })) |cached| {
- return cached;
- }
-
- const attr = element.getAttributeSafe(.wrap(@tagName(listener_type))) orelse return null;
- const function = frame.js.stringToPersistedFunction(attr, &.{"event"}, &.{}) catch |err| {
- // Not a valid expression; log this to find out if its something we should be supporting.
- log.debug(.js, "Html.getAttributeFunction", .{
- .expression = attr,
- .err = err,
- });
- return null;
- };
-
- try self.setAttributeListener(listener_type, function, frame);
- return function;
-}
-
-pub fn hasAttributeFunction(self: *HtmlElement, listener_type: GlobalEventHandler, frame: *const Frame) bool {
- return frame._event_target_attr_listeners.contains(.{ .target = self.asEventTarget(), .handler = listener_type });
-}
-
-fn setAttributeListener(
- self: *Element.Html,
- listener_type: GlobalEventHandler,
- listener_callback: ?js.Function.Global,
- frame: *Frame,
-) !void {
- if (comptime lp.IS_DEBUG) {
- log.debug(.event, "Html.setAttributeListener", .{
- .type = self._type,
- .listener_type = listener_type,
- });
- }
-
- if (listener_callback) |cb| {
- try frame._event_target_attr_listeners.put(frame.page_arena, .{
- .target = self.asEventTarget(),
- .handler = listener_type,
- }, cb);
+// An event handler content attribute (onclick="...") sets the handler to its
+// uncompiled source; removing the attribute (a null value) removes the
+// handler. `value` must be the element's stored attribute value: the handler
+// keeps it, uncopied.
+pub fn eventHandlerAttributeChanged(self: *HtmlElement, name: []const u8, value: ?[]const u8, frame: *Frame) !void {
+ if (global_event_handlers.isEventHandler(name) == false) {
return;
}
-
- // The listener is null, remove existing listener.
- _ = frame._event_target_attr_listeners.remove(.{
- .target = self.asEventTarget(),
- .handler = listener_type,
- });
-}
-
-pub fn setOnAbort(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onabort, callback, frame);
-}
-
-pub fn getOnAbort(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onabort, frame);
-}
-
-pub fn setOnAnimationCancel(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onanimationcancel, callback, frame);
-}
-
-pub fn getOnAnimationCancel(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onanimationcancel, frame);
-}
-
-pub fn setOnAnimationEnd(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onanimationend, callback, frame);
-}
-
-pub fn getOnAnimationEnd(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onanimationend, frame);
-}
-
-pub fn setOnAnimationIteration(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onanimationiteration, callback, frame);
-}
-
-pub fn getOnAnimationIteration(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onanimationiteration, frame);
-}
-
-pub fn setOnAnimationStart(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onanimationstart, callback, frame);
-}
-
-pub fn getOnAnimationStart(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onanimationstart, frame);
-}
-
-pub fn setOnAuxClick(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onauxclick, callback, frame);
-}
-
-pub fn getOnAuxClick(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onauxclick, frame);
-}
-
-pub fn setOnBeforeInput(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onbeforeinput, callback, frame);
-}
-
-pub fn getOnBeforeInput(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onbeforeinput, frame);
-}
-
-pub fn setOnBeforeMatch(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onbeforematch, callback, frame);
-}
-
-pub fn getOnBeforeMatch(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onbeforematch, frame);
-}
-
-pub fn setOnBeforeToggle(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onbeforetoggle, callback, frame);
-}
-
-pub fn getOnBeforeToggle(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onbeforetoggle, frame);
-}
-
-pub fn setOnBlur(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onblur, callback, frame);
-}
-
-pub fn getOnBlur(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onblur, frame);
-}
-
-pub fn setOnCancel(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oncancel, callback, frame);
-}
-
-pub fn getOnCancel(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oncancel, frame);
-}
-
-pub fn setOnCanPlay(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oncanplay, callback, frame);
-}
-
-pub fn getOnCanPlay(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oncanplay, frame);
-}
-
-pub fn setOnCanPlayThrough(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oncanplaythrough, callback, frame);
-}
-
-pub fn getOnCanPlayThrough(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oncanplaythrough, frame);
-}
-
-pub fn setOnChange(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onchange, callback, frame);
-}
-
-pub fn getOnChange(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onchange, frame);
-}
-
-pub fn setOnClick(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onclick, callback, frame);
-}
-
-pub fn getOnClick(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onclick, frame);
-}
-
-pub fn setOnClose(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onclose, callback, frame);
-}
-
-pub fn getOnClose(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onclose, frame);
-}
-
-pub fn setOnCommand(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oncommand, callback, frame);
-}
-
-pub fn getOnCommand(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oncommand, frame);
-}
-
-pub fn setOnContentVisibilityAutoStateChange(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oncontentvisibilityautostatechange, callback, frame);
-}
-
-pub fn getOnContentVisibilityAutoStateChange(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oncontentvisibilityautostatechange, frame);
-}
-
-pub fn setOnContextLost(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oncontextlost, callback, frame);
-}
-
-pub fn getOnContextLost(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oncontextlost, frame);
-}
-
-pub fn setOnContextMenu(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oncontextmenu, callback, frame);
-}
-
-pub fn getOnContextMenu(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oncontextmenu, frame);
-}
-
-pub fn setOnContextRestored(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oncontextrestored, callback, frame);
-}
-
-pub fn getOnContextRestored(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oncontextrestored, frame);
-}
-
-pub fn setOnCopy(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oncopy, callback, frame);
-}
-
-pub fn getOnCopy(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oncopy, frame);
-}
-
-pub fn setOnCueChange(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oncuechange, callback, frame);
-}
-
-pub fn getOnCueChange(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oncuechange, frame);
-}
-
-pub fn setOnCut(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oncut, callback, frame);
-}
-
-pub fn getOnCut(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oncut, frame);
-}
-
-pub fn setOnDblClick(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ondblclick, callback, frame);
-}
-
-pub fn getOnDblClick(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ondblclick, frame);
-}
-
-pub fn setOnDrag(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ondrag, callback, frame);
-}
-
-pub fn getOnDrag(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ondrag, frame);
-}
-
-pub fn setOnDragEnd(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ondragend, callback, frame);
-}
-
-pub fn getOnDragEnd(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ondragend, frame);
-}
-
-pub fn setOnDragEnter(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ondragenter, callback, frame);
-}
-
-pub fn getOnDragEnter(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ondragenter, frame);
-}
-
-pub fn setOnDragExit(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ondragexit, callback, frame);
-}
-
-pub fn getOnDragExit(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ondragexit, frame);
-}
-
-pub fn setOnDragLeave(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ondragleave, callback, frame);
-}
-
-pub fn getOnDragLeave(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ondragleave, frame);
-}
-
-pub fn setOnDragOver(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ondragover, callback, frame);
-}
-
-pub fn getOnDragOver(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ondragover, frame);
-}
-
-pub fn setOnDragStart(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ondragstart, callback, frame);
-}
-
-pub fn getOnDragStart(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ondragstart, frame);
-}
-
-pub fn setOnDrop(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ondrop, callback, frame);
-}
-
-pub fn getOnDrop(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ondrop, frame);
-}
-
-pub fn setOnDurationChange(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ondurationchange, callback, frame);
-}
-
-pub fn getOnDurationChange(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ondurationchange, frame);
-}
-
-pub fn setOnEmptied(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onemptied, callback, frame);
-}
-
-pub fn getOnEmptied(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onemptied, frame);
-}
-
-pub fn setOnEnded(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onended, callback, frame);
-}
-
-pub fn getOnEnded(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onended, frame);
-}
-
-pub fn setOnError(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onerror, callback, frame);
-}
-
-pub fn getOnError(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onerror, frame);
-}
-
-pub fn setOnFocus(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onfocus, callback, frame);
-}
-
-pub fn getOnFocus(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onfocus, frame);
-}
-
-pub fn setOnFormData(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onformdata, callback, frame);
-}
-
-pub fn getOnFormData(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onformdata, frame);
-}
-
-pub fn setOnFullscreenChange(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onfullscreenchange, callback, frame);
-}
-
-pub fn getOnFullscreenChange(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onfullscreenchange, frame);
-}
-
-pub fn setOnFullscreenError(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onfullscreenerror, callback, frame);
-}
-
-pub fn getOnFullscreenError(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onfullscreenerror, frame);
-}
-
-pub fn setOnGotPointerCapture(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ongotpointercapture, callback, frame);
-}
-
-pub fn getOnGotPointerCapture(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ongotpointercapture, frame);
-}
-
-pub fn setOnInput(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oninput, callback, frame);
-}
-
-pub fn getOnInput(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oninput, frame);
-}
-
-pub fn setOnInvalid(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.oninvalid, callback, frame);
-}
-
-pub fn getOnInvalid(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.oninvalid, frame);
-}
-
-pub fn setOnKeyDown(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onkeydown, callback, frame);
-}
-
-pub fn getOnKeyDown(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onkeydown, frame);
-}
-
-pub fn setOnKeyPress(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onkeypress, callback, frame);
-}
-
-pub fn getOnKeyPress(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onkeypress, frame);
-}
-
-pub fn setOnKeyUp(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onkeyup, callback, frame);
-}
-
-pub fn getOnKeyUp(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onkeyup, frame);
-}
-
-pub fn setOnLoad(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onload, callback, frame);
-}
-
-pub fn getOnLoad(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onload, frame);
-}
-
-pub fn setOnLoadedData(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onloadeddata, callback, frame);
-}
-
-pub fn getOnLoadedData(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onloadeddata, frame);
-}
-
-pub fn setOnLoadedMetadata(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onloadedmetadata, callback, frame);
-}
-
-pub fn getOnLoadedMetadata(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onloadedmetadata, frame);
-}
-
-pub fn setOnLoadStart(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onloadstart, callback, frame);
-}
-
-pub fn getOnLoadStart(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onloadstart, frame);
-}
-
-pub fn setOnLostPointerCapture(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onlostpointercapture, callback, frame);
-}
-
-pub fn getOnLostPointerCapture(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onlostpointercapture, frame);
-}
-
-pub fn setOnMouseDown(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onmousedown, callback, frame);
-}
-
-pub fn getOnMouseDown(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onmousedown, frame);
-}
-
-pub fn setOnMouseMove(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onmousemove, callback, frame);
-}
-
-pub fn getOnMouseMove(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onmousemove, frame);
-}
-
-pub fn setOnMouseOut(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onmouseout, callback, frame);
-}
-
-pub fn getOnMouseOut(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onmouseout, frame);
-}
-
-pub fn setOnMouseOver(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onmouseover, callback, frame);
-}
-
-pub fn getOnMouseOver(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onmouseover, frame);
-}
-
-pub fn setOnMouseUp(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onmouseup, callback, frame);
-}
-
-pub fn getOnMouseUp(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onmouseup, frame);
-}
-
-pub fn setOnPaste(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onpaste, callback, frame);
-}
-
-pub fn getOnPaste(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onpaste, frame);
-}
-
-pub fn setOnPause(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onpause, callback, frame);
-}
-
-pub fn getOnPause(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onpause, frame);
-}
-
-pub fn setOnPlay(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onplay, callback, frame);
-}
-
-pub fn getOnPlay(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onplay, frame);
-}
-
-pub fn setOnPlaying(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onplaying, callback, frame);
-}
-
-pub fn getOnPlaying(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onplaying, frame);
-}
-
-pub fn setOnPointerCancel(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onpointercancel, callback, frame);
-}
-
-pub fn getOnPointerCancel(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onpointercancel, frame);
-}
-
-pub fn setOnPointerDown(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onpointerdown, callback, frame);
-}
-
-pub fn getOnPointerDown(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onpointerdown, frame);
-}
-
-pub fn setOnPointerEnter(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onpointerenter, callback, frame);
-}
-
-pub fn getOnPointerEnter(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onpointerenter, frame);
-}
-
-pub fn setOnPointerLeave(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onpointerleave, callback, frame);
-}
-
-pub fn getOnPointerLeave(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onpointerleave, frame);
-}
-
-pub fn setOnPointerMove(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onpointermove, callback, frame);
-}
-
-pub fn getOnPointerMove(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onpointermove, frame);
-}
-
-pub fn setOnPointerOut(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onpointerout, callback, frame);
-}
-
-pub fn getOnPointerOut(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onpointerout, frame);
-}
-
-pub fn setOnPointerOver(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onpointerover, callback, frame);
-}
-
-pub fn getOnPointerOver(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onpointerover, frame);
-}
-
-pub fn setOnPointerRawUpdate(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onpointerrawupdate, callback, frame);
-}
-
-pub fn getOnPointerRawUpdate(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onpointerrawupdate, frame);
-}
-
-pub fn setOnPointerUp(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onpointerup, callback, frame);
-}
-
-pub fn getOnPointerUp(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onpointerup, frame);
-}
-
-pub fn setOnProgress(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onprogress, callback, frame);
-}
-
-pub fn getOnProgress(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onprogress, frame);
-}
-
-pub fn setOnRateChange(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onratechange, callback, frame);
-}
-
-pub fn getOnRateChange(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onratechange, frame);
-}
-
-pub fn setOnReset(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onreset, callback, frame);
-}
-
-pub fn getOnReset(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onreset, frame);
-}
-
-pub fn setOnResize(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onresize, callback, frame);
-}
-
-pub fn getOnResize(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onresize, frame);
-}
-
-pub fn setOnScroll(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onscroll, callback, frame);
-}
-
-pub fn getOnScroll(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onscroll, frame);
-}
-
-pub fn setOnScrollEnd(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onscrollend, callback, frame);
-}
-
-pub fn getOnScrollEnd(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onscrollend, frame);
-}
-
-pub fn setOnSecurityPolicyViolation(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onsecuritypolicyviolation, callback, frame);
-}
-
-pub fn getOnSecurityPolicyViolation(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onsecuritypolicyviolation, frame);
-}
-
-pub fn setOnSeeked(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onseeked, callback, frame);
-}
-
-pub fn getOnSeeked(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onseeked, frame);
-}
-
-pub fn setOnSeeking(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onseeking, callback, frame);
-}
-
-pub fn getOnSeeking(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onseeking, frame);
-}
-
-pub fn setOnSelect(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onselect, callback, frame);
-}
-
-pub fn getOnSelect(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onselect, frame);
-}
-
-pub fn setOnSelectionChange(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onselectionchange, callback, frame);
-}
-
-pub fn getOnSelectionChange(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onselectionchange, frame);
-}
-
-pub fn setOnSelectStart(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onselectstart, callback, frame);
-}
-
-pub fn getOnSelectStart(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onselectstart, frame);
-}
-
-pub fn setOnSlotChange(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onslotchange, callback, frame);
-}
-
-pub fn getOnSlotChange(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onslotchange, frame);
-}
-
-pub fn setOnStalled(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onstalled, callback, frame);
-}
-
-pub fn getOnStalled(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onstalled, frame);
-}
-
-pub fn setOnSubmit(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onsubmit, callback, frame);
-}
-
-pub fn getOnSubmit(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onsubmit, frame);
-}
-
-pub fn setOnSuspend(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onsuspend, callback, frame);
-}
-
-pub fn getOnSuspend(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onsuspend, frame);
-}
-
-pub fn setOnTimeUpdate(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ontimeupdate, callback, frame);
-}
-
-pub fn getOnTimeUpdate(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ontimeupdate, frame);
-}
-
-pub fn setOnToggle(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ontoggle, callback, frame);
-}
-
-pub fn getOnToggle(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ontoggle, frame);
-}
-
-pub fn setOnTouchCancel(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ontouchcancel, callback, frame);
-}
-
-pub fn getOnTouchCancel(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ontouchcancel, frame);
-}
-
-pub fn setOnTouchEnd(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ontouchend, callback, frame);
-}
-
-pub fn getOnTouchEnd(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ontouchend, frame);
-}
-
-pub fn setOnTouchMove(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ontouchmove, callback, frame);
-}
-
-pub fn getOnTouchMove(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ontouchmove, frame);
-}
-
-pub fn setOnTouchStart(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ontouchstart, callback, frame);
-}
-
-pub fn getOnTouchStart(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ontouchstart, frame);
-}
-
-pub fn setOnTransitionCancel(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ontransitioncancel, callback, frame);
-}
-
-pub fn getOnTransitionCancel(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ontransitioncancel, frame);
-}
-
-pub fn setOnTransitionEnd(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ontransitionend, callback, frame);
-}
-
-pub fn getOnTransitionEnd(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ontransitionend, frame);
-}
-
-pub fn setOnTransitionRun(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ontransitionrun, callback, frame);
-}
-
-pub fn getOnTransitionRun(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ontransitionrun, frame);
-}
-
-pub fn setOnTransitionStart(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.ontransitionstart, callback, frame);
-}
-
-pub fn getOnTransitionStart(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.ontransitionstart, frame);
-}
-
-pub fn setOnVolumeChange(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onvolumechange, callback, frame);
-}
-
-pub fn getOnVolumeChange(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onvolumechange, frame);
-}
-
-pub fn setOnWaiting(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onwaiting, callback, frame);
-}
-
-pub fn getOnWaiting(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onwaiting, frame);
-}
-
-pub fn setOnWheel(self: *HtmlElement, callback: ?js.Function.Global, frame: *Frame) !void {
- return self.setAttributeListener(.onwheel, callback, frame);
-}
-
-pub fn getOnWheel(self: *HtmlElement, frame: *Frame) !?js.Function.Global {
- return self.getAttributeFunction(.onwheel, frame);
+ const element = self.asElement();
+ switch (element.getTag()) {
+ // These belong to the Window (see Window.reflectingHandlerAccessor)
+ .body, .frameset => if (Window.isWindowReflectingHandler(name)) {
+ const owner = element.ownerFrame(frame) orelse return;
+ return owner._event_manager.setHandlerSource(owner.window.asEventTarget(), name[2..], value);
+ },
+ else => {},
+ }
+ return frame._event_manager.setHandlerSource(element.asEventTarget(), name[2..], value);
}
// HTML "rules for parsing integers", for callers that want an i32 (tabindex);
@@ -1899,105 +1072,105 @@ pub const JsApi = struct {
pub const tabIndex = bridge.accessor(HtmlElement.getTabIndex, HtmlElement.setTabIndex, .{ .ce_reactions = true });
pub const title = bridge.accessor(HtmlElement.getTitle, HtmlElement.setTitle, .{ .ce_reactions = true });
- pub const onabort = bridge.accessor(HtmlElement.getOnAbort, HtmlElement.setOnAbort, .{});
- pub const onanimationcancel = bridge.accessor(HtmlElement.getOnAnimationCancel, HtmlElement.setOnAnimationCancel, .{});
- pub const onanimationend = bridge.accessor(HtmlElement.getOnAnimationEnd, HtmlElement.setOnAnimationEnd, .{});
- pub const onanimationiteration = bridge.accessor(HtmlElement.getOnAnimationIteration, HtmlElement.setOnAnimationIteration, .{});
- pub const onanimationstart = bridge.accessor(HtmlElement.getOnAnimationStart, HtmlElement.setOnAnimationStart, .{});
- pub const onauxclick = bridge.accessor(HtmlElement.getOnAuxClick, HtmlElement.setOnAuxClick, .{});
- pub const onbeforeinput = bridge.accessor(HtmlElement.getOnBeforeInput, HtmlElement.setOnBeforeInput, .{});
- pub const onbeforematch = bridge.accessor(HtmlElement.getOnBeforeMatch, HtmlElement.setOnBeforeMatch, .{});
- pub const onbeforetoggle = bridge.accessor(HtmlElement.getOnBeforeToggle, HtmlElement.setOnBeforeToggle, .{});
- pub const onblur = bridge.accessor(HtmlElement.getOnBlur, HtmlElement.setOnBlur, .{});
- pub const oncancel = bridge.accessor(HtmlElement.getOnCancel, HtmlElement.setOnCancel, .{});
- pub const oncanplay = bridge.accessor(HtmlElement.getOnCanPlay, HtmlElement.setOnCanPlay, .{});
- pub const oncanplaythrough = bridge.accessor(HtmlElement.getOnCanPlayThrough, HtmlElement.setOnCanPlayThrough, .{});
- pub const onchange = bridge.accessor(HtmlElement.getOnChange, HtmlElement.setOnChange, .{});
- pub const onclick = bridge.accessor(HtmlElement.getOnClick, HtmlElement.setOnClick, .{});
- pub const onclose = bridge.accessor(HtmlElement.getOnClose, HtmlElement.setOnClose, .{});
- pub const oncommand = bridge.accessor(HtmlElement.getOnCommand, HtmlElement.setOnCommand, .{});
- pub const oncontentvisibilityautostatechange = bridge.accessor(HtmlElement.getOnContentVisibilityAutoStateChange, HtmlElement.setOnContentVisibilityAutoStateChange, .{});
- pub const oncontextlost = bridge.accessor(HtmlElement.getOnContextLost, HtmlElement.setOnContextLost, .{});
- pub const oncontextmenu = bridge.accessor(HtmlElement.getOnContextMenu, HtmlElement.setOnContextMenu, .{});
- pub const oncontextrestored = bridge.accessor(HtmlElement.getOnContextRestored, HtmlElement.setOnContextRestored, .{});
- pub const oncopy = bridge.accessor(HtmlElement.getOnCopy, HtmlElement.setOnCopy, .{});
- pub const oncuechange = bridge.accessor(HtmlElement.getOnCueChange, HtmlElement.setOnCueChange, .{});
- pub const oncut = bridge.accessor(HtmlElement.getOnCut, HtmlElement.setOnCut, .{});
- pub const ondblclick = bridge.accessor(HtmlElement.getOnDblClick, HtmlElement.setOnDblClick, .{});
- pub const ondrag = bridge.accessor(HtmlElement.getOnDrag, HtmlElement.setOnDrag, .{});
- pub const ondragend = bridge.accessor(HtmlElement.getOnDragEnd, HtmlElement.setOnDragEnd, .{});
- pub const ondragenter = bridge.accessor(HtmlElement.getOnDragEnter, HtmlElement.setOnDragEnter, .{});
- pub const ondragexit = bridge.accessor(HtmlElement.getOnDragExit, HtmlElement.setOnDragExit, .{});
- pub const ondragleave = bridge.accessor(HtmlElement.getOnDragLeave, HtmlElement.setOnDragLeave, .{});
- pub const ondragover = bridge.accessor(HtmlElement.getOnDragOver, HtmlElement.setOnDragOver, .{});
- pub const ondragstart = bridge.accessor(HtmlElement.getOnDragStart, HtmlElement.setOnDragStart, .{});
- pub const ondrop = bridge.accessor(HtmlElement.getOnDrop, HtmlElement.setOnDrop, .{});
- pub const ondurationchange = bridge.accessor(HtmlElement.getOnDurationChange, HtmlElement.setOnDurationChange, .{});
- pub const onemptied = bridge.accessor(HtmlElement.getOnEmptied, HtmlElement.setOnEmptied, .{});
- pub const onended = bridge.accessor(HtmlElement.getOnEnded, HtmlElement.setOnEnded, .{});
- pub const onerror = bridge.accessor(HtmlElement.getOnError, HtmlElement.setOnError, .{});
- pub const onfocus = bridge.accessor(HtmlElement.getOnFocus, HtmlElement.setOnFocus, .{});
- pub const onformdata = bridge.accessor(HtmlElement.getOnFormData, HtmlElement.setOnFormData, .{});
- pub const onfullscreenchange = bridge.accessor(HtmlElement.getOnFullscreenChange, HtmlElement.setOnFullscreenChange, .{});
- pub const onfullscreenerror = bridge.accessor(HtmlElement.getOnFullscreenError, HtmlElement.setOnFullscreenError, .{});
- pub const ongotpointercapture = bridge.accessor(HtmlElement.getOnGotPointerCapture, HtmlElement.setOnGotPointerCapture, .{});
- pub const oninput = bridge.accessor(HtmlElement.getOnInput, HtmlElement.setOnInput, .{});
- pub const oninvalid = bridge.accessor(HtmlElement.getOnInvalid, HtmlElement.setOnInvalid, .{});
- pub const onkeydown = bridge.accessor(HtmlElement.getOnKeyDown, HtmlElement.setOnKeyDown, .{});
- pub const onkeypress = bridge.accessor(HtmlElement.getOnKeyPress, HtmlElement.setOnKeyPress, .{});
- pub const onkeyup = bridge.accessor(HtmlElement.getOnKeyUp, HtmlElement.setOnKeyUp, .{});
- pub const onload = bridge.accessor(HtmlElement.getOnLoad, HtmlElement.setOnLoad, .{});
- pub const onloadeddata = bridge.accessor(HtmlElement.getOnLoadedData, HtmlElement.setOnLoadedData, .{});
- pub const onloadedmetadata = bridge.accessor(HtmlElement.getOnLoadedMetadata, HtmlElement.setOnLoadedMetadata, .{});
- pub const onloadstart = bridge.accessor(HtmlElement.getOnLoadStart, HtmlElement.setOnLoadStart, .{});
- pub const onlostpointercapture = bridge.accessor(HtmlElement.getOnLostPointerCapture, HtmlElement.setOnLostPointerCapture, .{});
- pub const onmousedown = bridge.accessor(HtmlElement.getOnMouseDown, HtmlElement.setOnMouseDown, .{});
- pub const onmousemove = bridge.accessor(HtmlElement.getOnMouseMove, HtmlElement.setOnMouseMove, .{});
- pub const onmouseout = bridge.accessor(HtmlElement.getOnMouseOut, HtmlElement.setOnMouseOut, .{});
- pub const onmouseover = bridge.accessor(HtmlElement.getOnMouseOver, HtmlElement.setOnMouseOver, .{});
- pub const onmouseup = bridge.accessor(HtmlElement.getOnMouseUp, HtmlElement.setOnMouseUp, .{});
- pub const onpaste = bridge.accessor(HtmlElement.getOnPaste, HtmlElement.setOnPaste, .{});
- pub const onpause = bridge.accessor(HtmlElement.getOnPause, HtmlElement.setOnPause, .{});
- pub const onplay = bridge.accessor(HtmlElement.getOnPlay, HtmlElement.setOnPlay, .{});
- pub const onplaying = bridge.accessor(HtmlElement.getOnPlaying, HtmlElement.setOnPlaying, .{});
- pub const onpointercancel = bridge.accessor(HtmlElement.getOnPointerCancel, HtmlElement.setOnPointerCancel, .{});
- pub const onpointerdown = bridge.accessor(HtmlElement.getOnPointerDown, HtmlElement.setOnPointerDown, .{});
- pub const onpointerenter = bridge.accessor(HtmlElement.getOnPointerEnter, HtmlElement.setOnPointerEnter, .{});
- pub const onpointerleave = bridge.accessor(HtmlElement.getOnPointerLeave, HtmlElement.setOnPointerLeave, .{});
- pub const onpointermove = bridge.accessor(HtmlElement.getOnPointerMove, HtmlElement.setOnPointerMove, .{});
- pub const onpointerout = bridge.accessor(HtmlElement.getOnPointerOut, HtmlElement.setOnPointerOut, .{});
- pub const onpointerover = bridge.accessor(HtmlElement.getOnPointerOver, HtmlElement.setOnPointerOver, .{});
- pub const onpointerrawupdate = bridge.accessor(HtmlElement.getOnPointerRawUpdate, HtmlElement.setOnPointerRawUpdate, .{});
- pub const onpointerup = bridge.accessor(HtmlElement.getOnPointerUp, HtmlElement.setOnPointerUp, .{});
- pub const onprogress = bridge.accessor(HtmlElement.getOnProgress, HtmlElement.setOnProgress, .{});
- pub const onratechange = bridge.accessor(HtmlElement.getOnRateChange, HtmlElement.setOnRateChange, .{});
- pub const onreset = bridge.accessor(HtmlElement.getOnReset, HtmlElement.setOnReset, .{});
- pub const onresize = bridge.accessor(HtmlElement.getOnResize, HtmlElement.setOnResize, .{});
- pub const onscroll = bridge.accessor(HtmlElement.getOnScroll, HtmlElement.setOnScroll, .{});
- pub const onscrollend = bridge.accessor(HtmlElement.getOnScrollEnd, HtmlElement.setOnScrollEnd, .{});
- pub const onsecuritypolicyviolation = bridge.accessor(HtmlElement.getOnSecurityPolicyViolation, HtmlElement.setOnSecurityPolicyViolation, .{});
- pub const onseeked = bridge.accessor(HtmlElement.getOnSeeked, HtmlElement.setOnSeeked, .{});
- pub const onseeking = bridge.accessor(HtmlElement.getOnSeeking, HtmlElement.setOnSeeking, .{});
- pub const onselect = bridge.accessor(HtmlElement.getOnSelect, HtmlElement.setOnSelect, .{});
- pub const onselectionchange = bridge.accessor(HtmlElement.getOnSelectionChange, HtmlElement.setOnSelectionChange, .{});
- pub const onselectstart = bridge.accessor(HtmlElement.getOnSelectStart, HtmlElement.setOnSelectStart, .{});
- pub const onslotchange = bridge.accessor(HtmlElement.getOnSlotChange, HtmlElement.setOnSlotChange, .{});
- pub const onstalled = bridge.accessor(HtmlElement.getOnStalled, HtmlElement.setOnStalled, .{});
- pub const onsubmit = bridge.accessor(HtmlElement.getOnSubmit, HtmlElement.setOnSubmit, .{});
- pub const onsuspend = bridge.accessor(HtmlElement.getOnSuspend, HtmlElement.setOnSuspend, .{});
- pub const ontimeupdate = bridge.accessor(HtmlElement.getOnTimeUpdate, HtmlElement.setOnTimeUpdate, .{});
- pub const ontoggle = bridge.accessor(HtmlElement.getOnToggle, HtmlElement.setOnToggle, .{});
- pub const ontouchcancel = bridge.accessor(HtmlElement.getOnTouchCancel, HtmlElement.setOnTouchCancel, .{});
- pub const ontouchend = bridge.accessor(HtmlElement.getOnTouchEnd, HtmlElement.setOnTouchEnd, .{});
- pub const ontouchmove = bridge.accessor(HtmlElement.getOnTouchMove, HtmlElement.setOnTouchMove, .{});
- pub const ontouchstart = bridge.accessor(HtmlElement.getOnTouchStart, HtmlElement.setOnTouchStart, .{});
- pub const ontransitioncancel = bridge.accessor(HtmlElement.getOnTransitionCancel, HtmlElement.setOnTransitionCancel, .{});
- pub const ontransitionend = bridge.accessor(HtmlElement.getOnTransitionEnd, HtmlElement.setOnTransitionEnd, .{});
- pub const ontransitionrun = bridge.accessor(HtmlElement.getOnTransitionRun, HtmlElement.setOnTransitionRun, .{});
- pub const ontransitionstart = bridge.accessor(HtmlElement.getOnTransitionStart, HtmlElement.setOnTransitionStart, .{});
- pub const onvolumechange = bridge.accessor(HtmlElement.getOnVolumeChange, HtmlElement.setOnVolumeChange, .{});
- pub const onwaiting = bridge.accessor(HtmlElement.getOnWaiting, HtmlElement.setOnWaiting, .{});
- pub const onwheel = bridge.accessor(HtmlElement.getOnWheel, HtmlElement.setOnWheel, .{});
+ pub const onabort = EventTarget.handlerAccessor(HtmlElement, "abort");
+ pub const onanimationcancel = EventTarget.handlerAccessor(HtmlElement, "animationcancel");
+ pub const onanimationend = EventTarget.handlerAccessor(HtmlElement, "animationend");
+ pub const onanimationiteration = EventTarget.handlerAccessor(HtmlElement, "animationiteration");
+ pub const onanimationstart = EventTarget.handlerAccessor(HtmlElement, "animationstart");
+ pub const onauxclick = EventTarget.handlerAccessor(HtmlElement, "auxclick");
+ pub const onbeforeinput = EventTarget.handlerAccessor(HtmlElement, "beforeinput");
+ pub const onbeforematch = EventTarget.handlerAccessor(HtmlElement, "beforematch");
+ pub const onbeforetoggle = EventTarget.handlerAccessor(HtmlElement, "beforetoggle");
+ pub const onblur = EventTarget.handlerAccessor(HtmlElement, "blur");
+ pub const oncancel = EventTarget.handlerAccessor(HtmlElement, "cancel");
+ pub const oncanplay = EventTarget.handlerAccessor(HtmlElement, "canplay");
+ pub const oncanplaythrough = EventTarget.handlerAccessor(HtmlElement, "canplaythrough");
+ pub const onchange = EventTarget.handlerAccessor(HtmlElement, "change");
+ pub const onclick = EventTarget.handlerAccessor(HtmlElement, "click");
+ pub const onclose = EventTarget.handlerAccessor(HtmlElement, "close");
+ pub const oncommand = EventTarget.handlerAccessor(HtmlElement, "command");
+ pub const oncontentvisibilityautostatechange = EventTarget.handlerAccessor(HtmlElement, "contentvisibilityautostatechange");
+ pub const oncontextlost = EventTarget.handlerAccessor(HtmlElement, "contextlost");
+ pub const oncontextmenu = EventTarget.handlerAccessor(HtmlElement, "contextmenu");
+ pub const oncontextrestored = EventTarget.handlerAccessor(HtmlElement, "contextrestored");
+ pub const oncopy = EventTarget.handlerAccessor(HtmlElement, "copy");
+ pub const oncuechange = EventTarget.handlerAccessor(HtmlElement, "cuechange");
+ pub const oncut = EventTarget.handlerAccessor(HtmlElement, "cut");
+ pub const ondblclick = EventTarget.handlerAccessor(HtmlElement, "dblclick");
+ pub const ondrag = EventTarget.handlerAccessor(HtmlElement, "drag");
+ pub const ondragend = EventTarget.handlerAccessor(HtmlElement, "dragend");
+ pub const ondragenter = EventTarget.handlerAccessor(HtmlElement, "dragenter");
+ pub const ondragexit = EventTarget.handlerAccessor(HtmlElement, "dragexit");
+ pub const ondragleave = EventTarget.handlerAccessor(HtmlElement, "dragleave");
+ pub const ondragover = EventTarget.handlerAccessor(HtmlElement, "dragover");
+ pub const ondragstart = EventTarget.handlerAccessor(HtmlElement, "dragstart");
+ pub const ondrop = EventTarget.handlerAccessor(HtmlElement, "drop");
+ pub const ondurationchange = EventTarget.handlerAccessor(HtmlElement, "durationchange");
+ pub const onemptied = EventTarget.handlerAccessor(HtmlElement, "emptied");
+ pub const onended = EventTarget.handlerAccessor(HtmlElement, "ended");
+ pub const onerror = EventTarget.handlerAccessor(HtmlElement, "error");
+ pub const onfocus = EventTarget.handlerAccessor(HtmlElement, "focus");
+ pub const onformdata = EventTarget.handlerAccessor(HtmlElement, "formdata");
+ pub const onfullscreenchange = EventTarget.handlerAccessor(HtmlElement, "fullscreenchange");
+ pub const onfullscreenerror = EventTarget.handlerAccessor(HtmlElement, "fullscreenerror");
+ pub const ongotpointercapture = EventTarget.handlerAccessor(HtmlElement, "gotpointercapture");
+ pub const oninput = EventTarget.handlerAccessor(HtmlElement, "input");
+ pub const oninvalid = EventTarget.handlerAccessor(HtmlElement, "invalid");
+ pub const onkeydown = EventTarget.handlerAccessor(HtmlElement, "keydown");
+ pub const onkeypress = EventTarget.handlerAccessor(HtmlElement, "keypress");
+ pub const onkeyup = EventTarget.handlerAccessor(HtmlElement, "keyup");
+ pub const onload = EventTarget.handlerAccessor(HtmlElement, "load");
+ pub const onloadeddata = EventTarget.handlerAccessor(HtmlElement, "loadeddata");
+ pub const onloadedmetadata = EventTarget.handlerAccessor(HtmlElement, "loadedmetadata");
+ pub const onloadstart = EventTarget.handlerAccessor(HtmlElement, "loadstart");
+ pub const onlostpointercapture = EventTarget.handlerAccessor(HtmlElement, "lostpointercapture");
+ pub const onmousedown = EventTarget.handlerAccessor(HtmlElement, "mousedown");
+ pub const onmousemove = EventTarget.handlerAccessor(HtmlElement, "mousemove");
+ pub const onmouseout = EventTarget.handlerAccessor(HtmlElement, "mouseout");
+ pub const onmouseover = EventTarget.handlerAccessor(HtmlElement, "mouseover");
+ pub const onmouseup = EventTarget.handlerAccessor(HtmlElement, "mouseup");
+ pub const onpaste = EventTarget.handlerAccessor(HtmlElement, "paste");
+ pub const onpause = EventTarget.handlerAccessor(HtmlElement, "pause");
+ pub const onplay = EventTarget.handlerAccessor(HtmlElement, "play");
+ pub const onplaying = EventTarget.handlerAccessor(HtmlElement, "playing");
+ pub const onpointercancel = EventTarget.handlerAccessor(HtmlElement, "pointercancel");
+ pub const onpointerdown = EventTarget.handlerAccessor(HtmlElement, "pointerdown");
+ pub const onpointerenter = EventTarget.handlerAccessor(HtmlElement, "pointerenter");
+ pub const onpointerleave = EventTarget.handlerAccessor(HtmlElement, "pointerleave");
+ pub const onpointermove = EventTarget.handlerAccessor(HtmlElement, "pointermove");
+ pub const onpointerout = EventTarget.handlerAccessor(HtmlElement, "pointerout");
+ pub const onpointerover = EventTarget.handlerAccessor(HtmlElement, "pointerover");
+ pub const onpointerrawupdate = EventTarget.handlerAccessor(HtmlElement, "pointerrawupdate");
+ pub const onpointerup = EventTarget.handlerAccessor(HtmlElement, "pointerup");
+ pub const onprogress = EventTarget.handlerAccessor(HtmlElement, "progress");
+ pub const onratechange = EventTarget.handlerAccessor(HtmlElement, "ratechange");
+ pub const onreset = EventTarget.handlerAccessor(HtmlElement, "reset");
+ pub const onresize = EventTarget.handlerAccessor(HtmlElement, "resize");
+ pub const onscroll = EventTarget.handlerAccessor(HtmlElement, "scroll");
+ pub const onscrollend = EventTarget.handlerAccessor(HtmlElement, "scrollend");
+ pub const onsecuritypolicyviolation = EventTarget.handlerAccessor(HtmlElement, "securitypolicyviolation");
+ pub const onseeked = EventTarget.handlerAccessor(HtmlElement, "seeked");
+ pub const onseeking = EventTarget.handlerAccessor(HtmlElement, "seeking");
+ pub const onselect = EventTarget.handlerAccessor(HtmlElement, "select");
+ pub const onselectionchange = EventTarget.handlerAccessor(HtmlElement, "selectionchange");
+ pub const onselectstart = EventTarget.handlerAccessor(HtmlElement, "selectstart");
+ pub const onslotchange = EventTarget.handlerAccessor(HtmlElement, "slotchange");
+ pub const onstalled = EventTarget.handlerAccessor(HtmlElement, "stalled");
+ pub const onsubmit = EventTarget.handlerAccessor(HtmlElement, "submit");
+ pub const onsuspend = EventTarget.handlerAccessor(HtmlElement, "suspend");
+ pub const ontimeupdate = EventTarget.handlerAccessor(HtmlElement, "timeupdate");
+ pub const ontoggle = EventTarget.handlerAccessor(HtmlElement, "toggle");
+ pub const ontouchcancel = EventTarget.handlerAccessor(HtmlElement, "touchcancel");
+ pub const ontouchend = EventTarget.handlerAccessor(HtmlElement, "touchend");
+ pub const ontouchmove = EventTarget.handlerAccessor(HtmlElement, "touchmove");
+ pub const ontouchstart = EventTarget.handlerAccessor(HtmlElement, "touchstart");
+ pub const ontransitioncancel = EventTarget.handlerAccessor(HtmlElement, "transitioncancel");
+ pub const ontransitionend = EventTarget.handlerAccessor(HtmlElement, "transitionend");
+ pub const ontransitionrun = EventTarget.handlerAccessor(HtmlElement, "transitionrun");
+ pub const ontransitionstart = EventTarget.handlerAccessor(HtmlElement, "transitionstart");
+ pub const onvolumechange = EventTarget.handlerAccessor(HtmlElement, "volumechange");
+ pub const onwaiting = EventTarget.handlerAccessor(HtmlElement, "waiting");
+ pub const onwheel = EventTarget.handlerAccessor(HtmlElement, "wheel");
};
pub const Build = struct {
diff --git a/src/browser/webapi/element/html/Body.zig b/src/browser/webapi/element/html/Body.zig
index 84a545a43..1efdee629 100644
--- a/src/browser/webapi/element/html/Body.zig
+++ b/src/browser/webapi/element/html/Body.zig
@@ -18,7 +18,6 @@
const lp = @import("lightpanda");
const js = @import("../../../js/js.zig");
-const Frame = @import("../../../Frame.zig");
const Factory = @import("../../../Factory.zig");
const Node = @import("../../Node.zig");
@@ -26,8 +25,6 @@ const Element = @import("../../Element.zig");
const Window = @import("../../Window.zig");
const HtmlElement = @import("../Html.zig");
-const String = lp.String;
-
const Body = @This();
pub const Proto = HtmlElement;
@@ -42,59 +39,6 @@ pub fn asNode(self: *Body) *Node {
return self.asElement().asNode();
}
-// Special-case: the "window-reflecting body element event handler set"
-// (blur, error, focus, load, resize, scroll) are aliases for the Window's
-// event handlers.
-
-// The aliased Window is the one of the element's node document's frame — not
-// the caller's frame, which differs when a same-origin script reaches into
-// another frame (e.g. the parent setting iframeDoc.body.onblur).
-fn reflectedWindow(self: *Body, frame: *Frame) ?*Window {
- return (self.asElement().ownerFrame(frame) orelse return null).window;
-}
-
-fn getOnBlur(self: *Body, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_blur;
-}
-fn setOnBlur(self: *Body, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_blur = Window.getFunctionFromSetter(setter);
-}
-
-fn getOnError(self: *Body, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_error;
-}
-fn setOnError(self: *Body, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_error = Window.getFunctionFromSetter(setter);
-}
-
-fn getOnFocus(self: *Body, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_focus;
-}
-fn setOnFocus(self: *Body, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_focus = Window.getFunctionFromSetter(setter);
-}
-
-fn getOnLoad(self: *Body, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_load;
-}
-fn setOnLoad(self: *Body, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_load = Window.getFunctionFromSetter(setter);
-}
-
-fn getOnResize(self: *Body, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_resize;
-}
-fn setOnResize(self: *Body, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_resize = Window.getFunctionFromSetter(setter);
-}
-
-fn getOnScroll(self: *Body, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_scroll;
-}
-fn setOnScroll(self: *Body, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_scroll = Window.getFunctionFromSetter(setter);
-}
-
pub const JsApi = struct {
pub const bridge = js.Bridge(Body);
@@ -112,36 +56,10 @@ pub const JsApi = struct {
pub const background = reflect.string("background");
pub const aLink = reflect.stringNullToEmpty("alink");
- pub const onblur = bridge.accessor(getOnBlur, setOnBlur, .{ .null_as_undefined = false });
- pub const onerror = bridge.accessor(getOnError, setOnError, .{ .null_as_undefined = false });
- pub const onfocus = bridge.accessor(getOnFocus, setOnFocus, .{ .null_as_undefined = false });
- pub const onload = bridge.accessor(getOnLoad, setOnLoad, .{ .null_as_undefined = false });
- pub const onresize = bridge.accessor(getOnResize, setOnResize, .{ .null_as_undefined = false });
- pub const onscroll = bridge.accessor(getOnScroll, setOnScroll, .{ .null_as_undefined = false });
-};
-
-pub const Build = struct {
- const window_reflecting_attributes = [_][]const u8{
- "onblur", "onerror", "onfocus", "onload", "onresize", "onscroll",
- };
-
- pub fn complete(node: *Node, frame: *Frame) !void {
- const el = node.as(Element);
- const owner = node.ownerFrame(frame) orelse return;
- inline for (window_reflecting_attributes) |attr| {
- if (el.getAttributeSafe(comptime .wrap(attr))) |value| {
- owner.window.setWindowReflectingHandlerFromAttribute(comptime .wrap(attr), value, owner);
- }
- }
- }
-
- pub fn attributeChange(el: *Element, name: String, value: String, frame: *Frame) !void {
- const owner = el.ownerFrame(frame) orelse return;
- owner.window.setWindowReflectingHandlerFromAttribute(name, value.str(), owner);
- }
-
- pub fn attributeRemove(el: *Element, name: String, frame: *Frame) !void {
- const owner = el.ownerFrame(frame) orelse return;
- owner.window.setWindowReflectingHandlerFromAttribute(name, null, owner);
- }
+ pub const onblur = Window.reflectingHandlerAccessor(Body, "blur");
+ pub const onerror = Window.reflectingHandlerAccessor(Body, "error");
+ pub const onfocus = Window.reflectingHandlerAccessor(Body, "focus");
+ pub const onload = Window.reflectingHandlerAccessor(Body, "load");
+ pub const onresize = Window.reflectingHandlerAccessor(Body, "resize");
+ pub const onscroll = Window.reflectingHandlerAccessor(Body, "scroll");
};
diff --git a/src/browser/webapi/element/html/FrameSet.zig b/src/browser/webapi/element/html/FrameSet.zig
index fb4789a9a..a2b13eea3 100644
--- a/src/browser/webapi/element/html/FrameSet.zig
+++ b/src/browser/webapi/element/html/FrameSet.zig
@@ -18,7 +18,6 @@
const lp = @import("lightpanda");
const js = @import("../../../js/js.zig");
-const Frame = @import("../../../Frame.zig");
const Factory = @import("../../../Factory.zig");
const Node = @import("../../Node.zig");
@@ -27,8 +26,6 @@ const Element = @import("../../Element.zig");
const HtmlElement = @import("../Html.zig");
-const String = lp.String;
-
const FrameSet = @This();
pub const Proto = HtmlElement;
@@ -43,59 +40,6 @@ pub fn asNode(self: *FrameSet) *Node {
return self.asElement().asNode();
}
-// Special-case: the "window-reflecting body element event handler set"
-// (blur, error, focus, load, resize, scroll) are aliases for the Window's
-// event handlers, on frameset elements just like on body elements.
-
-// The aliased Window is the one of the element's node document's frame — not
-// the caller's frame, which differs when a same-origin script reaches into
-// another frame (e.g. the parent setting a handler on a child frameset).
-fn reflectedWindow(self: *FrameSet, frame: *Frame) ?*Window {
- return (self.asElement().ownerFrame(frame) orelse return null).window;
-}
-
-fn getOnBlur(self: *FrameSet, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_blur;
-}
-fn setOnBlur(self: *FrameSet, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_blur = Window.getFunctionFromSetter(setter);
-}
-
-fn getOnError(self: *FrameSet, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_error;
-}
-fn setOnError(self: *FrameSet, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_error = Window.getFunctionFromSetter(setter);
-}
-
-fn getOnFocus(self: *FrameSet, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_focus;
-}
-fn setOnFocus(self: *FrameSet, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_focus = Window.getFunctionFromSetter(setter);
-}
-
-fn getOnLoad(self: *FrameSet, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_load;
-}
-fn setOnLoad(self: *FrameSet, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_load = Window.getFunctionFromSetter(setter);
-}
-
-fn getOnResize(self: *FrameSet, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_resize;
-}
-fn setOnResize(self: *FrameSet, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_resize = Window.getFunctionFromSetter(setter);
-}
-
-fn getOnScroll(self: *FrameSet, frame: *Frame) ?js.Function.Global {
- return (self.reflectedWindow(frame) orelse return null)._on_scroll;
-}
-fn setOnScroll(self: *FrameSet, setter: ?Window.FunctionSetter, frame: *Frame) !void {
- (self.reflectedWindow(frame) orelse return)._on_scroll = Window.getFunctionFromSetter(setter);
-}
-
pub const JsApi = struct {
pub const bridge = js.Bridge(FrameSet);
@@ -110,38 +54,12 @@ pub const JsApi = struct {
pub const cols = reflect.string("cols");
pub const rows = reflect.string("rows");
- pub const onblur = bridge.accessor(getOnBlur, setOnBlur, .{ .null_as_undefined = false });
- pub const onerror = bridge.accessor(getOnError, setOnError, .{ .null_as_undefined = false });
- pub const onfocus = bridge.accessor(getOnFocus, setOnFocus, .{ .null_as_undefined = false });
- pub const onload = bridge.accessor(getOnLoad, setOnLoad, .{ .null_as_undefined = false });
- pub const onresize = bridge.accessor(getOnResize, setOnResize, .{ .null_as_undefined = false });
- pub const onscroll = bridge.accessor(getOnScroll, setOnScroll, .{ .null_as_undefined = false });
-};
-
-pub const Build = struct {
- const window_reflecting_attributes = [_][]const u8{
- "onblur", "onerror", "onfocus", "onload", "onresize", "onscroll",
- };
-
- pub fn complete(node: *Node, frame: *Frame) !void {
- const el = node.as(Element);
- const owner = node.ownerFrame(frame) orelse return;
- inline for (window_reflecting_attributes) |attr| {
- if (el.getAttributeSafe(comptime .wrap(attr))) |value| {
- owner.window.setWindowReflectingHandlerFromAttribute(comptime .wrap(attr), value, owner);
- }
- }
- }
-
- pub fn attributeChange(el: *Element, name: String, value: String, frame: *Frame) !void {
- const owner = el.ownerFrame(frame) orelse return;
- owner.window.setWindowReflectingHandlerFromAttribute(name, value.str(), owner);
- }
-
- pub fn attributeRemove(el: *Element, name: String, frame: *Frame) !void {
- const owner = el.ownerFrame(frame) orelse return;
- owner.window.setWindowReflectingHandlerFromAttribute(name, null, owner);
- }
+ pub const onblur = Window.reflectingHandlerAccessor(FrameSet, "blur");
+ pub const onerror = Window.reflectingHandlerAccessor(FrameSet, "error");
+ pub const onfocus = Window.reflectingHandlerAccessor(FrameSet, "focus");
+ pub const onload = Window.reflectingHandlerAccessor(FrameSet, "load");
+ pub const onresize = Window.reflectingHandlerAccessor(FrameSet, "resize");
+ pub const onscroll = Window.reflectingHandlerAccessor(FrameSet, "scroll");
};
const testing = @import("../../../../testing.zig");
diff --git a/src/browser/webapi/element/html/Input.zig b/src/browser/webapi/element/html/Input.zig
index 46a062ed3..c537c8390 100644
--- a/src/browser/webapi/element/html/Input.zig
+++ b/src/browser/webapi/element/html/Input.zig
@@ -122,20 +122,6 @@ _selection_start: u32 = 0,
_selection_end: u32 = 0,
_selection_direction: Selection.SelectionDirection = .none,
-_on_selectionchange: ?js.Function.Global = null,
-
-fn getOnSelectionChange(self: *Input) ?js.Function.Global {
- return self._on_selectionchange;
-}
-
-fn setOnSelectionChange(self: *Input, listener: ?js.Function) !void {
- if (listener) |listen| {
- self._on_selectionchange = try listen.persistWithThis(self);
- } else {
- self._on_selectionchange = null;
- }
-}
-
pub fn asElement(self: *Input) *Element {
return Factory.protoOf(self).asElement();
}
@@ -1525,7 +1511,6 @@ pub const JsApi = struct {
return self.setValue(try js_value.toZig([]const u8), frame);
}
- pub const onselectionchange = bridge.accessor(Input.getOnSelectionChange, Input.setOnSelectionChange, .{});
pub const @"type" = bridge.accessor(Input.getType, Input.setType, .{ .ce_reactions = true });
pub const value = bridge.accessor(Input.getValueForJS, setValueFromJS, .{ .ce_reactions = true });
pub const valueAsNumber = bridge.accessor(Input.getValueAsNumber, Input.setValueAsNumber, .{});
diff --git a/src/browser/webapi/element/html/TextArea.zig b/src/browser/webapi/element/html/TextArea.zig
index 8b3f535f3..428760804 100644
--- a/src/browser/webapi/element/html/TextArea.zig
+++ b/src/browser/webapi/element/html/TextArea.zig
@@ -48,22 +48,9 @@ _selection_start: u32 = 0,
_selection_end: u32 = 0,
_selection_direction: Selection.SelectionDirection = .none,
-_on_selectionchange: ?js.Function.Global = null,
_custom_validity: ?[]const u8 = null,
_validity: ?*ValidityState = null,
-fn getOnSelectionChange(self: *TextArea) ?js.Function.Global {
- return self._on_selectionchange;
-}
-
-fn setOnSelectionChange(self: *TextArea, listener: ?js.Function) !void {
- if (listener) |listen| {
- self._on_selectionchange = try listen.persistWithThis(self);
- } else {
- self._on_selectionchange = null;
- }
-}
-
pub fn asElement(self: *TextArea) *Element {
return Factory.protoOf(self).asElement();
}
@@ -278,7 +265,6 @@ pub const JsApi = struct {
pub const checkValidity = bridge.function(TextArea.checkValidity, .{});
pub const reportValidity = bridge.function(TextArea.reportValidity, .{});
pub const setCustomValidity = bridge.function(TextArea.setCustomValidity, .{});
- pub const onselectionchange = bridge.accessor(TextArea.getOnSelectionChange, TextArea.setOnSelectionChange, .{});
pub const @"type" = bridge.property("textarea", .{ .template = false, .readonly = true });
pub const value = bridge.accessor(TextArea.getValue, TextArea.setValue, .{});
pub const defaultValue = bridge.accessor(TextArea.getDefaultValue, TextArea.setDefaultValue, .{ .ce_reactions = true });
diff --git a/src/browser/webapi/global_event_handlers.zig b/src/browser/webapi/global_event_handlers.zig
index 1de308562..cd5f53509 100644
--- a/src/browser/webapi/global_event_handlers.zig
+++ b/src/browser/webapi/global_event_handlers.zig
@@ -17,55 +17,9 @@
// along with this program. If not, see <https://www.gnu.org/licenses/>.
const std = @import("std");
-const lp = @import("lightpanda");
-const js = @import("../js/js.zig");
-
-const EventTarget = @import("EventTarget.zig");
-
-const Key = struct {
- target: *EventTarget,
- handler: Handler,
-
- /// Fuses `target` pointer and `handler` enum; used at hashing.
- /// NEVER use a fusion to retrieve a pointer back. Portability is not guaranteed.
- /// See `Context.hash`.
- fn fuse(self: *const Key) u64 {
- // Check if we have 3 bits available from alignment of 8.
- if (comptime lp.IS_DEBUG) {
- lp.assert(@alignOf(EventTarget) == 8, "Key.fuse: incorrect alignment", .{
- .event_target_alignment = @alignOf(EventTarget),
- });
- }
-
- const ptr = @intFromPtr(self.target) >> 3;
- if (comptime lp.IS_DEBUG) {
- lp.assert(ptr < (1 << 57), "Key.fuse: pointer overflow", .{ .ptr = ptr });
- }
- return ptr | (@as(u64, @backingInt(self.handler)) << 57);
- }
-};
-
-const Context = struct {
- pub fn hash(_: @This(), key: Key) u64 {
- return std.hash.int(key.fuse());
- }
-
- pub fn eql(_: @This(), a: Key, b: Key) bool {
- return a.fuse() == b.fuse();
- }
-};
-
-pub const Lookup = std.HashMapUnmanaged(
- Key,
- js.Function.Global,
- Context,
- std.hash_map.default_max_load_percentage,
-);
-
-/// Enum of known event listeners; increasing the size of it (u7)
-/// can cause `Key` to behave incorrectly.
-pub const Handler = enum(u7) {
+/// The event handlers (onclick, ...) of HTML elements.
+pub const Handler = enum {
onabort,
onanimationcancel,
onanimationend,
@@ -167,23 +121,26 @@ pub const Handler = enum(u7) {
onwheel,
};
-const typeToHandler = std.StaticStringMap(Handler).initComptime(blk: {
- const info = @typeInfo(Handler).@"enum";
- var entries: [info.field_names.len]struct { []const u8, Handler } = undefined;
- for (info.field_names, info.field_values, 0..) |field_name, field_value, i| {
- entries[i] = .{ field_name[2..], @fromBackingInt(field_value) };
+const handlers = std.StaticStringMap(void).initComptime(blk: {
+ const names = @typeInfo(Handler).@"enum".field_names;
+ var entries: [names.len]struct { []const u8 } = undefined;
+ for (names, 0..) |name, i| {
+ entries[i] = .{name};
}
break :blk entries;
});
-pub fn fromEventType(typ: []const u8) ?Handler {
- return typeToHandler.get(typ);
+/// Whether `name` (e.g. "onclick") is an event handler content attribute.
+pub fn isEventHandler(name: []const u8) bool {
+ return handlers.has(name);
}
const testing = @import("../../testing.zig");
-test "GlobalEventHandlers: fromEventType" {
- try testing.expectEqual(.onabort, fromEventType("abort"));
- try testing.expectEqual(.onselect, fromEventType("select"));
- try testing.expectEqual(null, fromEventType(""));
- try testing.expectEqual(null, fromEventType("unknown"));
+test "GlobalEventHandlers: isEventHandler" {
+ try testing.expectEqual(true, isEventHandler("onabort"));
+ try testing.expectEqual(true, isEventHandler("onselect"));
+ try testing.expectEqual(false, isEventHandler("abort"));
+ try testing.expectEqual(false, isEventHandler("on"));
+ try testing.expectEqual(false, isEventHandler(""));
+ try testing.expectEqual(false, isEventHandler("onunknown"));
}
diff --git a/src/browser/webapi/media/TextTrackCue.zig b/src/browser/webapi/media/TextTrackCue.zig
index d9f6f2150..4f31d4458 100644
--- a/src/browser/webapi/media/TextTrackCue.zig
+++ b/src/browser/webapi/media/TextTrackCue.zig
@@ -31,8 +31,6 @@ _id: []const u8 = "",
_start_time: f64 = 0,
_end_time: f64 = 0,
_pause_on_exit: bool = false,
-_on_enter: ?js.Function.Global = null,
-_on_exit: ?js.Function.Global = null,
pub const Type = union(enum) {
vtt: *@import("VTTCue.zig"),
@@ -74,22 +72,6 @@ fn setPauseOnExit(self: *TextTrackCue, value: bool) void {
self._pause_on_exit = value;
}
-fn getOnEnter(self: *const TextTrackCue) ?js.Function.Global {
- return self._on_enter;
-}
-
-fn setOnEnter(self: *TextTrackCue, cb: ?js.Function.Global) !void {
- self._on_enter = cb;
-}
-
-fn getOnExit(self: *const TextTrackCue) ?js.Function.Global {
- return self._on_exit;
-}
-
-fn setOnExit(self: *TextTrackCue, cb: ?js.Function.Global) !void {
- self._on_exit = cb;
-}
-
pub const JsApi = struct {
pub const bridge = js.Bridge(TextTrackCue);
@@ -106,6 +88,6 @@ pub const JsApi = struct {
pub const startTime = bridge.accessor(TextTrackCue.getStartTime, TextTrackCue.setStartTime, .{});
pub const endTime = bridge.accessor(TextTrackCue.getEndTime, TextTrackCue.setEndTime, .{});
pub const pauseOnExit = bridge.accessor(TextTrackCue.getPauseOnExit, TextTrackCue.setPauseOnExit, .{});
- pub const onenter = bridge.accessor(TextTrackCue.getOnEnter, TextTrackCue.setOnEnter, .{});
- pub const onexit = bridge.accessor(TextTrackCue.getOnExit, TextTrackCue.setOnExit, .{});
+ pub const onenter = EventTarget.handlerAccessor(TextTrackCue, "enter");
+ pub const onexit = EventTarget.handlerAccessor(TextTrackCue, "exit");
};
diff --git a/src/browser/webapi/navigation/Navigation.zig b/src/browser/webapi/navigation/Navigation.zig
index 277db7aa7..c42121cc9 100644
--- a/src/browser/webapi/navigation/Navigation.zig
+++ b/src/browser/webapi/navigation/Navigation.zig
@@ -44,9 +44,6 @@ const NavigationHistoryEntry = @import("NavigationHistoryEntry.zig");
const NavigationCurrentEntryChangeEvent = @import("../event/NavigationCurrentEntryChangeEvent.zig");
_proto: *EventTarget,
-_on_currententrychange: ?js.Function.Global = null,
-_on_navigatesuccess: ?js.Function.Global = null,
-_on_navigateerror: ?js.Function.Global = null,
_current_navigation_kind: ?NavigationKind = null,
@@ -61,26 +58,10 @@ _activation: ?NavigationActivation = null,
// from that initial entry replaces it.
_initial_entry: bool = false,
-fn asEventTarget(self: *Navigation) *EventTarget {
+pub fn asEventTarget(self: *Navigation) *EventTarget {
return self._proto;
}
-pub fn onRemoveFrame(self: *Navigation) void {
- if (self._on_currententrychange) |cb| cb.release();
- self._on_currententrychange = null;
-
- if (self._on_navigatesuccess) |cb| cb.release();
- self._on_navigatesuccess = null;
-
- if (self._on_navigateerror) |cb| cb.release();
- self._on_navigateerror = null;
-
- for (self._entries.items) |entry| {
- if (entry._on_dispose) |cb| cb.release();
- entry._on_dispose = null;
- }
-}
-
fn getActivation(self: *const Navigation) ?NavigationActivation {
return self._activation;
}
@@ -323,11 +304,7 @@ pub fn replaceEntry(
}
fn fireNavigateSuccess(self: *Navigation, frame: *Frame) !void {
- if (!frame.hasDirectListeners(
- self.asEventTarget(),
- "navigatesuccess",
- self._on_navigatesuccess,
- )) {
+ if (!frame.hasDirectListeners(self.asEventTarget(), "navigatesuccess")) {
return;
}
@@ -340,7 +317,7 @@ fn fireNavigateSuccess(self: *Navigation, frame: *Frame) !void {
return;
};
- try self.dispatch(self._on_navigatesuccess, event, frame);
+ try self.dispatch(event, frame);
}
fn fireCurrentEntryChangeEvent(
@@ -349,11 +326,7 @@ fn fireCurrentEntryChangeEvent(
kind: ?NavigationKind,
frame: *Frame,
) !void {
- if (!frame.hasDirectListeners(
- self.asEventTarget(),
- "currententrychange",
- self._on_currententrychange,
- )) {
+ if (!frame.hasDirectListeners(self.asEventTarget(), "currententrychange")) {
return;
}
@@ -370,7 +343,7 @@ fn fireCurrentEntryChangeEvent(
return;
};
- try self.dispatch(self._on_currententrychange, event.asEvent(), frame);
+ try self.dispatch(event.asEvent(), frame);
}
fn resolveFinished(
@@ -562,44 +535,8 @@ fn updateCurrentEntry(self: *Navigation, options: UpdateCurrentEntryOptions, fra
try self.fireCurrentEntryChangeEvent(previous, null, frame);
}
-pub fn dispatch(self: *Navigation, func: ?js.Function.Global, event: *Event, frame: *Frame) !void {
- return frame.dispatch(
- self.asEventTarget(),
- event,
- func,
- .{ .context = "Navigation" },
- );
-}
-
-fn getOnCurrentEntryChange(self: *Navigation) ?js.Function.Global {
- return self._on_currententrychange;
-}
-
-fn setOnCurrentEntryChange(self: *Navigation, listener: ?js.Function) !void {
- if (self._on_currententrychange) |old| old.release();
- if (listener) |listen| {
- self._on_currententrychange = try listen.persistWithThis(self);
- } else {
- self._on_currententrychange = null;
- }
-}
-
-fn getOnNavigateSuccess(self: *Navigation) ?js.Function.Global {
- return self._on_navigatesuccess;
-}
-
-fn setOnNavigateSuccess(self: *Navigation, listener: ?js.Function) !void {
- if (self._on_navigatesuccess) |old| old.release();
- self._on_navigatesuccess = if (listener) |l| try l.persistWithThis(self) else null;
-}
-
-fn getOnNavigateError(self: *Navigation) ?js.Function.Global {
- return self._on_navigateerror;
-}
-
-fn setOnNavigateError(self: *Navigation, listener: ?js.Function) !void {
- if (self._on_navigateerror) |old| old.release();
- self._on_navigateerror = if (listener) |l| try l.persistWithThis(self) else null;
+pub fn dispatch(self: *Navigation, event: *Event, frame: *Frame) !void {
+ return frame.dispatch(self.asEventTarget(), event, .{ .context = "Navigation" });
}
pub const JsApi = struct {
@@ -624,21 +561,9 @@ pub const JsApi = struct {
pub const traverseTo = bridge.function(Navigation.traverseTo, .{});
pub const updateCurrentEntry = bridge.function(Navigation.updateCurrentEntry, .{});
- pub const oncurrententrychange = bridge.accessor(
- Navigation.getOnCurrentEntryChange,
- Navigation.setOnCurrentEntryChange,
- .{},
- );
- pub const onnavigatesuccess = bridge.accessor(
- Navigation.getOnNavigateSuccess,
- Navigation.setOnNavigateSuccess,
- .{},
- );
- pub const onnavigateerror = bridge.accessor(
- Navigation.getOnNavigateError,
- Navigation.setOnNavigateError,
- .{},
- );
+ pub const oncurrententrychange = EventTarget.handlerAccessor(Navigation, "currententrychange");
+ pub const onnavigatesuccess = EventTarget.handlerAccessor(Navigation, "navigatesuccess");
+ pub const onnavigateerror = EventTarget.handlerAccessor(Navigation, "navigateerror");
};
const testing = @import("../../../testing.zig");
diff --git a/src/browser/webapi/navigation/NavigationHistoryEntry.zig b/src/browser/webapi/navigation/NavigationHistoryEntry.zig
index bdaab163e..68ba31490 100644
--- a/src/browser/webapi/navigation/NavigationHistoryEntry.zig
+++ b/src/browser/webapi/navigation/NavigationHistoryEntry.zig
@@ -38,9 +38,7 @@ _state: NavigationState,
// document's id; traversing between them stays in that document.
_document_id: u32,
-_on_dispose: ?js.Function.Global = null,
-
-fn asEventTarget(self: *NavigationHistoryEntry) *EventTarget {
+pub fn asEventTarget(self: *NavigationHistoryEntry) *EventTarget {
return self._proto;
}
@@ -89,23 +87,10 @@ pub fn getState(self: *const NavigationHistoryEntry, frame: *Frame) !StateReturn
}
pub fn fireDispose(self: *NavigationHistoryEntry, frame: *Frame) !void {
- if (!frame.hasDirectListeners(self.asEventTarget(), "dispose", self._on_dispose)) return;
+ if (!frame.hasDirectListeners(self.asEventTarget(), "dispose")) return;
const event = try Event.initTrusted(comptime .wrap("dispose"), .{}, frame.page);
- try frame.dispatch(self.asEventTarget(), event, self._on_dispose, .{ .context = "NavigationHistoryEntry" });
-}
-
-fn getOnDispose(self: *const NavigationHistoryEntry) ?js.Function.Global {
- return self._on_dispose;
-}
-
-fn setOnDispose(self: *NavigationHistoryEntry, cb_: ?js.Function) !void {
- if (self._on_dispose) |od| od.release();
- if (cb_) |cb| {
- self._on_dispose = try cb.persistWithThis(self);
- } else {
- self._on_dispose = null;
- }
+ try frame.dispatch(self.asEventTarget(), event, .{ .context = "NavigationHistoryEntry" });
}
pub const JsApi = struct {
@@ -123,9 +108,5 @@ pub const JsApi = struct {
pub const sameDocument = bridge.accessor(NavigationHistoryEntry.sameDocument, null, .{});
pub const url = bridge.accessor(NavigationHistoryEntry.url, null, .{});
pub const getState = bridge.function(NavigationHistoryEntry.getState, .{});
- pub const ondispose = bridge.accessor(
- NavigationHistoryEntry.getOnDispose,
- NavigationHistoryEntry.setOnDispose,
- .{},
- );
+ pub const ondispose = EventTarget.handlerAccessor(NavigationHistoryEntry, "dispose");
};
diff --git a/src/browser/webapi/net/EventSource.zig b/src/browser/webapi/net/EventSource.zig
index 8a2275570..8b13a2e87 100644
--- a/src/browser/webapi/net/EventSource.zig
+++ b/src/browser/webapi/net/EventSource.zig
@@ -78,10 +78,6 @@ _skip_lf: bool = false,
// A single leading BOM is stripped from the stream's first line.
_bom_checked: bool = false,
-_on_open: ?js.Function.Global = null,
-_on_message: ?js.Function.Global = null,
-_on_error: ?js.Function.Global = null,
-
const ReadyState = enum(u8) {
connecting = 0,
open = 1,
@@ -135,16 +131,6 @@ pub fn deinit(self: *EventSource, page: *Page) void {
transfer.cancel();
}
- if (self._on_open) |func| {
- func.release();
- }
- if (self._on_message) |func| {
- func.release();
- }
- if (self._on_error) |func| {
- func.release();
- }
-
page.event_listeners.removeTarget(self.asEventTarget());
self._arena.release();
}
@@ -157,7 +143,7 @@ pub fn acquireRef(self: *EventSource) void {
self._rc.acquire();
}
-fn asEventTarget(self: *EventSource) *EventTarget {
+pub fn asEventTarget(self: *EventSource) *EventTarget {
return self._proto;
}
@@ -247,7 +233,7 @@ fn failConnection(self: *EventSource) void {
return;
}
self._ready_state = .closed;
- self.dispatchEvent("error", self._on_error) catch |err| {
+ self.dispatchEvent("error") catch |err| {
log.debug(.http, "EventSource error event", .{ .err = err, .url = self._url });
};
self.deactivate();
@@ -258,7 +244,7 @@ fn reestablish(self: *EventSource) void {
return;
}
self._ready_state = .connecting;
- self.dispatchEvent("error", self._on_error) catch |err| {
+ self.dispatchEvent("error") catch |err| {
log.debug(.http, "EventSource error event", .{ .err = err, .url = self._url });
};
// the error handler may have close()d us
@@ -337,7 +323,7 @@ fn httpHeaderDoneCallback(transfer: *Transfer) !Transfer.HeaderResult {
// https://html.spec.whatwg.org/multipage/server-sent-events.html#announce-the-connection
self._ready_state = .open;
- try self.dispatchEvent("open", self._on_open);
+ try self.dispatchEvent("open");
return .proceed;
}
@@ -537,13 +523,12 @@ fn dispatchPending(self: *EventSource) !void {
const exec = self._exec;
const target = self.asEventTarget();
- const handler: ?js.Function.Global = if (is_message) self._on_message else null;
if (is_message) {
- if (!exec.hasDirectListeners(target, "message", handler)) {
+ if (!exec.hasDirectListeners(target, "message")) {
return;
}
- } else if (!exec.hasDirectListeners(target, type_buf, handler)) {
+ } else if (!exec.hasDirectListeners(target, type_buf)) {
return;
}
@@ -554,15 +539,15 @@ fn dispatchPending(self: *EventSource) !void {
.origin = self._event_origin,
.lastEventId = self._last_event_id.items,
}, exec.page);
- try exec.dispatch(target, event.asEvent(), handler, .{ .context = "EventSource message" });
+ try exec.dispatch(target, event.asEvent(), .{ .context = "EventSource message" });
}
-fn dispatchEvent(self: *EventSource, comptime name: []const u8, handler: ?js.Function.Global) !void {
+fn dispatchEvent(self: *EventSource, comptime name: []const u8) !void {
const exec = self._exec;
const target = self.asEventTarget();
- if (exec.hasDirectListeners(target, name, handler)) {
+ if (exec.hasDirectListeners(target, name)) {
const event = try Event.initTrusted(comptime .wrap(name), .{}, exec.page);
- try exec.dispatch(target, event, handler, .{ .context = "EventSource " ++ name });
+ try exec.dispatch(target, event, .{ .context = "EventSource " ++ name });
}
}
@@ -578,39 +563,6 @@ fn getWithCredentials(self: *const EventSource) bool {
return self._with_credentials;
}
-fn getOnOpen(self: *const EventSource) ?js.Function.Global {
- return self._on_open;
-}
-
-fn setOnOpen(self: *EventSource, cb_: ?js.Function) !void {
- if (self._on_open) |old| {
- old.release();
- }
- self._on_open = if (cb_) |cb| try cb.persistWithThis(self) else null;
-}
-
-fn getOnMessage(self: *const EventSource) ?js.Function.Global {
- return self._on_message;
-}
-
-fn setOnMessage(self: *EventSource, cb_: ?js.Function) !void {
- if (self._on_message) |old| {
- old.release();
- }
- self._on_message = if (cb_) |cb| try cb.persistWithThis(self) else null;
-}
-
-fn getOnError(self: *const EventSource) ?js.Function.Global {
- return self._on_error;
-}
-
-fn setOnError(self: *EventSource, cb_: ?js.Function) !void {
- if (self._on_error) |old| {
- old.release();
- }
- self._on_error = if (cb_) |cb| try cb.persistWithThis(self) else null;
-}
-
pub const JsApi = struct {
pub const bridge = js.Bridge(EventSource);
@@ -630,9 +582,9 @@ pub const JsApi = struct {
pub const readyState = bridge.accessor(EventSource.getReadyState, null, .{});
pub const withCredentials = bridge.accessor(EventSource.getWithCredentials, null, .{});
- pub const onopen = bridge.accessor(EventSource.getOnOpen, EventSource.setOnOpen, .{});
- pub const onmessage = bridge.accessor(EventSource.getOnMessage, EventSource.setOnMessage, .{});
- pub const onerror = bridge.accessor(EventSource.getOnError, EventSource.setOnError, .{});
+ pub const onopen = EventTarget.handlerAccessor(EventSource, "open");
+ pub const onmessage = EventTarget.handlerAccessor(EventSource, "message");
+ pub const onerror = EventTarget.handlerAccessor(EventSource, "error");
pub const close = bridge.function(EventSource.close, .{});
};
diff --git a/src/browser/webapi/net/WebSocket.zig b/src/browser/webapi/net/WebSocket.zig
index 004f3b333..f1084831f 100644
--- a/src/browser/webapi/net/WebSocket.zig
+++ b/src/browser/webapi/net/WebSocket.zig
@@ -96,10 +96,6 @@ _close_reason: []const u8 = "",
_protocol: []const u8 = "",
// Event handlers
-_on_open: ?js.Function.Global = null,
-_on_message: ?js.Function.Global = null,
-_on_error: ?js.Function.Global = null,
-_on_close: ?js.Function.Global = null,
const ReadyState = enum(u8) {
connecting = 0,
@@ -288,19 +284,6 @@ fn isBlockedPort(url: [:0]const u8) bool {
pub fn deinit(self: *WebSocket, page: *Page) void {
self.releaseTransport();
- if (self._on_open) |func| {
- func.release();
- }
- if (self._on_message) |func| {
- func.release();
- }
- if (self._on_error) |func| {
- func.release();
- }
- if (self._on_close) |func| {
- func.release();
- }
-
for (self._send_queue.items) |msg| {
msg.deinit(page);
}
@@ -321,7 +304,7 @@ pub fn acquireRef(self: *WebSocket) void {
self._rc.acquire();
}
-fn asEventTarget(self: *WebSocket) *EventTarget {
+pub fn asEventTarget(self: *WebSocket) *EventTarget {
return self._proto;
}
@@ -688,65 +671,13 @@ fn setBinaryType(self: *WebSocket, value: []const u8) void {
}
}
-fn getOnOpen(self: *const WebSocket) ?js.Function.Global {
- return self._on_open;
-}
-
-fn setOnOpen(self: *WebSocket, cb_: ?js.Function) !void {
- if (self._on_open) |old| old.release();
- if (cb_) |cb| {
- self._on_open = try cb.persistWithThis(self);
- } else {
- self._on_open = null;
- }
-}
-
-fn getOnMessage(self: *const WebSocket) ?js.Function.Global {
- return self._on_message;
-}
-
-fn setOnMessage(self: *WebSocket, cb_: ?js.Function) !void {
- if (self._on_message) |old| old.release();
- if (cb_) |cb| {
- self._on_message = try cb.persistWithThis(self);
- } else {
- self._on_message = null;
- }
-}
-
-fn getOnError(self: *const WebSocket) ?js.Function.Global {
- return self._on_error;
-}
-
-fn setOnError(self: *WebSocket, cb_: ?js.Function) !void {
- if (self._on_error) |old| old.release();
- if (cb_) |cb| {
- self._on_error = try cb.persistWithThis(self);
- } else {
- self._on_error = null;
- }
-}
-
-fn getOnClose(self: *const WebSocket) ?js.Function.Global {
- return self._on_close;
-}
-
-fn setOnClose(self: *WebSocket, cb_: ?js.Function) !void {
- if (self._on_close) |old| old.release();
- if (cb_) |cb| {
- self._on_close = try cb.persistWithThis(self);
- } else {
- self._on_close = null;
- }
-}
-
fn dispatchOpenEvent(self: *WebSocket) !void {
const exec = self._exec;
const target = self.asEventTarget();
- if (exec.hasDirectListeners(target, "open", self._on_open)) {
+ if (exec.hasDirectListeners(target, "open")) {
const event = try Event.initTrusted(comptime .wrap("open"), .{}, exec.page);
- try exec.dispatch(target, event, self._on_open, .{ .context = "WebSocket open" });
+ try exec.dispatch(target, event, .{ .context = "WebSocket open" });
}
}
@@ -754,7 +685,7 @@ fn dispatchMessageEvent(self: *WebSocket, data: []const u8, frame_type: http.WsF
const exec = self._exec;
const target = self.asEventTarget();
- if (exec.hasDirectListeners(target, "message", self._on_message)) {
+ if (exec.hasDirectListeners(target, "message")) {
const msg_data: MessageEvent.Data = if (frame_type == .binary)
switch (self._binary_type) {
.arraybuffer => .{ .arraybuffer = .{ .values = data } },
@@ -771,7 +702,7 @@ fn dispatchMessageEvent(self: *WebSocket, data: []const u8, frame_type: http.WsF
.data = msg_data,
.origin = "",
}, exec.page);
- try exec.dispatch(target, event.asEvent(), self._on_message, .{ .context = "WebSocket message" });
+ try exec.dispatch(target, event.asEvent(), .{ .context = "WebSocket message" });
}
}
@@ -779,9 +710,9 @@ fn dispatchErrorEvent(self: *WebSocket) !void {
const exec = self._exec;
const target = self.asEventTarget();
- if (exec.hasDirectListeners(target, "error", self._on_error)) {
+ if (exec.hasDirectListeners(target, "error")) {
const event = try Event.initTrusted(comptime .wrap("error"), .{}, exec.page);
- try exec.dispatch(target, event, self._on_error, .{ .context = "WebSocket error" });
+ try exec.dispatch(target, event, .{ .context = "WebSocket error" });
}
}
@@ -789,13 +720,13 @@ fn dispatchCloseEvent(self: *WebSocket, code: u16, reason: []const u8, was_clean
const exec = self._exec;
const target = self.asEventTarget();
- if (exec.hasDirectListeners(target, "close", self._on_close)) {
+ if (exec.hasDirectListeners(target, "close")) {
const event = try CloseEvent.initTrusted(comptime .wrap("close"), .{
.code = code,
.reason = reason,
.wasClean = was_clean,
}, exec.page);
- try exec.dispatch(target, event.asEvent(), self._on_close, .{ .context = "WebSocket close" });
+ try exec.dispatch(target, event.asEvent(), .{ .context = "WebSocket close" });
}
}
@@ -1045,10 +976,10 @@ pub const JsApi = struct {
pub const protocol = bridge.accessor(WebSocket.getProtocol, null, .{});
pub const extensions = bridge.property("", .{ .template = false });
- pub const onopen = bridge.accessor(WebSocket.getOnOpen, WebSocket.setOnOpen, .{});
- pub const onmessage = bridge.accessor(WebSocket.getOnMessage, WebSocket.setOnMessage, .{});
- pub const onerror = bridge.accessor(WebSocket.getOnError, WebSocket.setOnError, .{});
- pub const onclose = bridge.accessor(WebSocket.getOnClose, WebSocket.setOnClose, .{});
+ pub const onopen = EventTarget.handlerAccessor(WebSocket, "open");
+ pub const onmessage = EventTarget.handlerAccessor(WebSocket, "message");
+ pub const onerror = EventTarget.handlerAccessor(WebSocket, "error");
+ pub const onclose = EventTarget.handlerAccessor(WebSocket, "close");
pub const send = bridge.function(WebSocket.send, .{});
pub const close = bridge.function(WebSocket.close, .{});
diff --git a/src/browser/webapi/net/XMLHttpRequest.zig b/src/browser/webapi/net/XMLHttpRequest.zig
index 950d4e2d4..e8c7e28c7 100644
--- a/src/browser/webapi/net/XMLHttpRequest.zig
+++ b/src/browser/webapi/net/XMLHttpRequest.zig
@@ -78,7 +78,6 @@ _response_headers: std.ArrayList(http.Header) = .empty,
_response_type: ResponseType = .default,
_ready_state: ReadyState = .unsent,
-_on_ready_state_change: ?js.Function.Global = null,
_with_credentials: bool = false,
_timeout: u32 = 0,
@@ -145,13 +144,7 @@ pub fn deinit(self: *XMLHttpRequest, page: *Page) void {
self.clearResponse(page);
- if (self._on_ready_state_change) |func| {
- func.release();
- }
-
- self._proto.releaseListeners();
if (self._upload) |upload| {
- upload._proto.releaseListeners();
page.event_listeners.removeTarget(upload.asEventTarget());
}
page.event_listeners.removeTarget(self.asEventTarget());
@@ -177,22 +170,10 @@ pub fn acquireRef(self: *XMLHttpRequest) void {
self._rc.acquire();
}
-fn asEventTarget(self: *XMLHttpRequest) *EventTarget {
+pub fn asEventTarget(self: *XMLHttpRequest) *EventTarget {
return self._proto._proto;
}
-fn getOnReadyStateChange(self: *const XMLHttpRequest) ?js.Function.Global {
- return self._on_ready_state_change;
-}
-
-fn setOnReadyStateChange(self: *XMLHttpRequest, cb_: ?js.Function) !void {
- if (cb_) |cb| {
- self._on_ready_state_change = try cb.persistWithThis(self);
- } else {
- self._on_ready_state_change = null;
- }
-}
-
fn getWithCredentials(self: *const XMLHttpRequest) bool {
return self._with_credentials;
}
@@ -860,9 +841,9 @@ fn stateChanged(self: *XMLHttpRequest, state: ReadyState, exec: *const Execution
self._ready_state = state;
const target = self.asEventTarget();
- if (exec.hasDirectListeners(target, "readystatechange", self._on_ready_state_change)) {
+ if (exec.hasDirectListeners(target, "readystatechange")) {
const event = try Event.initTrusted(.wrap("readystatechange"), .{}, exec.page);
- try exec.dispatch(target, event, self._on_ready_state_change, .{ .context = "XHR state change" });
+ try exec.dispatch(target, event, .{ .context = "XHR state change" });
}
}
@@ -894,7 +875,7 @@ pub const JsApi = struct {
pub const LOADING = bridge.property(@backingInt(XMLHttpRequest.ReadyState.loading), .{ .template = true });
pub const DONE = bridge.property(@backingInt(XMLHttpRequest.ReadyState.done), .{ .template = true });
- pub const onreadystatechange = bridge.accessor(XMLHttpRequest.getOnReadyStateChange, XMLHttpRequest.setOnReadyStateChange, .{});
+ pub const onreadystatechange = EventTarget.handlerAccessor(XMLHttpRequest, "readystatechange");
pub const upload = bridge.accessor(XMLHttpRequest.getUpload, null, .{});
pub const timeout = bridge.accessor(XMLHttpRequest.getTimeout, XMLHttpRequest.setTimeout, .{});
pub const withCredentials = bridge.accessor(XMLHttpRequest.getWithCredentials, XMLHttpRequest.setWithCredentials, .{});
@@ -952,6 +933,8 @@ test "WebApi: XHR listeners are dropped when the XHR is freed" {
\\for (let i = 0; i < 200; i++) {
\\ new XMLHttpRequest().addEventListener('foo', () => fired++);
\\ new XMLHttpRequest().upload.addEventListener('foo', () => fired++);
+ \\ new XMLHttpRequest().onload = () => fired++;
+ \\ new XMLHttpRequest().upload.onload = () => fired++;
\\}
, null);
}
@@ -969,6 +952,8 @@ test "WebApi: XHR listeners are dropped when the XHR is freed" {
\\for (let i = 0; i < 200; i++) {
\\ new XMLHttpRequest().dispatchEvent(new Event('foo'));
\\ new XMLHttpRequest().upload.dispatchEvent(new Event('foo'));
+ \\ new XMLHttpRequest().dispatchEvent(new Event('load'));
+ \\ new XMLHttpRequest().upload.dispatchEvent(new Event('load'));
\\}
\\fired;
, null);
diff --git a/src/browser/webapi/net/XMLHttpRequestEventTarget.zig b/src/browser/webapi/net/XMLHttpRequestEventTarget.zig
index 242771663..7b0229967 100644
--- a/src/browser/webapi/net/XMLHttpRequestEventTarget.zig
+++ b/src/browser/webapi/net/XMLHttpRequestEventTarget.zig
@@ -16,7 +16,6 @@
// You should have received a copy of the GNU Affero General Public License
// along with this program. If not, see <https://www.gnu.org/licenses/>.
-const lp = @import("lightpanda");
const js = @import("../../js/js.zig");
const EventTarget = @import("../EventTarget.zig");
@@ -30,13 +29,6 @@ pub const Proto = EventTarget;
_type: Type,
_proto: *EventTarget,
-_on_abort: ?js.Function.Global = null,
-_on_error: ?js.Function.Global = null,
-_on_load: ?js.Function.Global = null,
-_on_load_end: ?js.Function.Global = null,
-_on_load_start: ?js.Function.Global = null,
-_on_progress: ?js.Function.Global = null,
-_on_timeout: ?js.Function.Global = null,
pub const Type = union(enum) {
request: *@import("XMLHttpRequest.zig"),
@@ -47,28 +39,15 @@ pub fn asEventTarget(self: *XMLHttpRequestEventTarget) *EventTarget {
return self._proto;
}
-pub fn releaseListeners(self: *XMLHttpRequestEventTarget) void {
- inline for (.{
- "_on_abort", "_on_error", "_on_load", "_on_load_end",
- "_on_load_start", "_on_progress", "_on_timeout",
- }) |field| {
- if (@field(self, field)) |func| {
- func.release();
- }
- }
-}
-
pub fn dispatch(self: *XMLHttpRequestEventTarget, comptime event_type: DispatchType, progress_: ?Progress, exec: *const Execution) !void {
- const field, const typ = comptime blk: {
- break :blk switch (event_type) {
- .abort => .{ "_on_abort", "abort" },
- .err => .{ "_on_error", "error" },
- .load => .{ "_on_load", "load" },
- .load_end => .{ "_on_load_end", "loadend" },
- .load_start => .{ "_on_load_start", "loadstart" },
- .progress => .{ "_on_progress", "progress" },
- .timeout => .{ "_on_timeout", "timeout" },
- };
+ const typ = comptime switch (event_type) {
+ .abort => "abort",
+ .err => "error",
+ .load => "load",
+ .load_end => "loadend",
+ .load_start => "loadstart",
+ .progress => "progress",
+ .timeout => "timeout",
};
const progress = progress_ orelse Progress{};
@@ -85,85 +64,10 @@ pub fn dispatch(self: *XMLHttpRequestEventTarget, comptime event_type: DispatchT
return exec.dispatch(
self.asEventTarget(),
event,
- @field(self, field),
.{ .context = "XHR " ++ typ },
);
}
-// Resolves the property event handler for the given event type, so that a
-// script-dispatched event (target.dispatchEvent) fires it like the internal
-// dispatch path does.
-pub fn inlineHandler(self: *const XMLHttpRequestEventTarget, typ: lp.String) ?js.Function.Global {
- if (typ.eql(comptime .wrap("abort"))) return self._on_abort;
- if (typ.eql(comptime .wrap("error"))) return self._on_error;
- if (typ.eql(comptime .wrap("load"))) return self._on_load;
- if (typ.eql(comptime .wrap("loadend"))) return self._on_load_end;
- if (typ.eql(comptime .wrap("loadstart"))) return self._on_load_start;
- if (typ.eql(comptime .wrap("progress"))) return self._on_progress;
- if (typ.eql(comptime .wrap("timeout"))) return self._on_timeout;
- return null;
-}
-
-fn getOnAbort(self: *const XMLHttpRequestEventTarget) ?js.Function.Global {
- return self._on_abort;
-}
-
-fn setOnAbort(self: *XMLHttpRequestEventTarget, cb: ?js.Function.Global) !void {
- self._on_abort = cb;
-}
-
-fn getOnError(self: *const XMLHttpRequestEventTarget) ?js.Function.Global {
- return self._on_error;
-}
-
-fn setOnError(self: *XMLHttpRequestEventTarget, cb: ?js.Function.Global) !void {
- self._on_error = cb;
-}
-
-fn getOnLoad(self: *const XMLHttpRequestEventTarget) ?js.Function.Global {
- return self._on_load;
-}
-
-fn setOnLoad(self: *XMLHttpRequestEventTarget, cb: ?js.Function.Global) !void {
- self._on_load = cb;
-}
-
-fn getOnLoadEnd(self: *const XMLHttpRequestEventTarget) ?js.Function.Global {
- return self._on_load_end;
-}
-
-fn setOnLoadEnd(self: *XMLHttpRequestEventTarget, cb: ?js.Function.Global) !void {
- self._on_load_end = cb;
-}
-
-fn getOnLoadStart(self: *const XMLHttpRequestEventTarget) ?js.Function.Global {
- return self._on_load_start;
-}
-
-fn setOnLoadStart(self: *XMLHttpRequestEventTarget, cb: ?js.Function.Global) !void {
- self._on_load_start = cb;
-}
-
-fn getOnProgress(self: *const XMLHttpRequestEventTarget) ?js.Function.Global {
- return self._on_progress;
-}
-
-fn setOnProgress(self: *XMLHttpRequestEventTarget, cb: ?js.Function.Global) !void {
- self._on_progress = cb;
-}
-
-fn getOnTimeout(self: *const XMLHttpRequestEventTarget) ?js.Function.Global {
- return self._on_timeout;
-}
-
-fn setOnTimeout(self: *XMLHttpRequestEventTarget, cb_: ?js.Function) !void {
- if (cb_) |cb| {
- self._on_timeout = try cb.persistWithThis(self);
- } else {
- self._on_timeout = null;
- }
-}
-
const DispatchType = enum {
abort,
err,
@@ -189,11 +93,11 @@ pub const JsApi = struct {
pub var class_id: bridge.ClassId = undefined;
};
- pub const onloadstart = bridge.accessor(XMLHttpRequestEventTarget.getOnLoadStart, XMLHttpRequestEventTarget.setOnLoadStart, .{});
- pub const onprogress = bridge.accessor(XMLHttpRequestEventTarget.getOnProgress, XMLHttpRequestEventTarget.setOnProgress, .{});
- pub const onabort = bridge.accessor(XMLHttpRequestEventTarget.getOnAbort, XMLHttpRequestEventTarget.setOnAbort, .{});
- pub const onerror = bridge.accessor(XMLHttpRequestEventTarget.getOnError, XMLHttpRequestEventTarget.setOnError, .{});
- pub const onload = bridge.accessor(XMLHttpRequestEventTarget.getOnLoad, XMLHttpRequestEventTarget.setOnLoad, .{});
- pub const ontimeout = bridge.accessor(XMLHttpRequestEventTarget.getOnTimeout, XMLHttpRequestEventTarget.setOnTimeout, .{});
- pub const onloadend = bridge.accessor(XMLHttpRequestEventTarget.getOnLoadEnd, XMLHttpRequestEventTarget.setOnLoadEnd, .{});
+ pub const onloadstart = EventTarget.handlerAccessor(XMLHttpRequestEventTarget, "loadstart");
+ pub const onprogress = EventTarget.handlerAccessor(XMLHttpRequestEventTarget, "progress");
+ pub const onabort = EventTarget.handlerAccessor(XMLHttpRequestEventTarget, "abort");
+ pub const onerror = EventTarget.handlerAccessor(XMLHttpRequestEventTarget, "error");
+ pub const onload = EventTarget.handlerAccessor(XMLHttpRequestEventTarget, "load");
+ pub const ontimeout = EventTarget.handlerAccessor(XMLHttpRequestEventTarget, "timeout");
+ pub const onloadend = EventTarget.handlerAccessor(XMLHttpRequestEventTarget, "loadend");
};
diff --git a/src/browser/webapi/net/XMLHttpRequestUpload.zig b/src/browser/webapi/net/XMLHttpRequestUpload.zig
index ceb90fea5..f715e3a22 100644
--- a/src/browser/webapi/net/XMLHttpRequestUpload.zig
+++ b/src/browser/webapi/net/XMLHttpRequestUpload.zig
@@ -37,10 +37,6 @@ pub const Proto = XMLHttpRequestEventTarget;
_proto: *XMLHttpRequestEventTarget,
_xhr: *XMLHttpRequest,
-// pub fn deinit(self: *XMLHttpRequestUpload, _: *Page) void {
-// self._proto.releaseListeners();
-// }
-
pub fn releaseRef(self: *XMLHttpRequestUpload, page: *Page) void {
self._xhr.releaseRef(page);
}
diff --git a/src/browser/webapi/storage/CookieStore.zig b/src/browser/webapi/storage/CookieStore.zig
index f3c16259d..754917416 100644
--- a/src/browser/webapi/storage/CookieStore.zig
+++ b/src/browser/webapi/storage/CookieStore.zig
@@ -36,7 +36,6 @@ const CookieStore = @This();
pub const Proto = EventTarget;
_proto: *EventTarget,
-_on_change: ?js.Function.Global = null,
_exec: ?*Execution = null,
pub fn asEventTarget(self: *CookieStore) *EventTarget {
@@ -92,7 +91,7 @@ fn onCookieChanged(ctx: *anyopaque, data: *const Notification.CookieChanged) !vo
// Rechecked in ChangeCallback.run, but between now and then, a listener
// could be added which should NOT get this event (because it wasn't addded
// at this point).
- if (!exec.hasDirectListeners(self.asEventTarget(), "change", self._on_change)) {
+ if (!exec.hasDirectListeners(self.asEventTarget(), "change")) {
return;
}
@@ -158,7 +157,7 @@ const ChangeCallback = struct {
const target = cs.asEventTarget();
// Skip event construction when nobody is listening.
- if (!exec.hasDirectListeners(target, "change", cs._on_change)) {
+ if (!exec.hasDirectListeners(target, "change")) {
return null;
}
@@ -173,7 +172,7 @@ const ChangeCallback = struct {
.same_site = self.same_site,
}, exec);
- try exec.dispatch(target, event.asEvent(), cs._on_change, .{
+ try exec.dispatch(target, event.asEvent(), .{
.context = "CookieStore.change",
});
@@ -181,26 +180,6 @@ const ChangeCallback = struct {
}
};
-fn getOnChange(self: *const CookieStore) ?js.Function.Global {
- return self._on_change;
-}
-
-fn setOnChange(self: *CookieStore, setter: ?FunctionSetter) void {
- const s = setter orelse {
- self._on_change = null;
- return;
- };
- self._on_change = switch (s) {
- .func => |f| f,
- .anything => null,
- };
-}
-
-const FunctionSetter = union(enum) {
- func: js.Function.Global,
- anything: js.Value,
-};
-
// https://developer.mozilla.org/en-US/docs/Web/API/CookieStore/get
const GetOptions = struct {
name: ?[]const u8 = null,
@@ -569,7 +548,7 @@ pub const JsApi = struct {
pub const getAll = bridge.function(CookieStore.getAll, .{});
pub const set = bridge.function(CookieStore.set, .{});
pub const delete = bridge.function(CookieStore.delete, .{});
- pub const onchange = bridge.accessor(CookieStore.getOnChange, CookieStore.setOnChange, .{});
+ pub const onchange = EventTarget.handlerAccessor(CookieStore, "change");
};
// CookieListItem is an plain JavaScript object, not an interface. The bridge
diff --git a/src/browser/webapi/storage/idb/IDBDatabase.zig b/src/browser/webapi/storage/idb/IDBDatabase.zig
index c8c8884fd..f60f2f8c9 100644
--- a/src/browser/webapi/storage/idb/IDBDatabase.zig
+++ b/src/browser/webapi/storage/idb/IDBDatabase.zig
@@ -22,15 +22,12 @@ const js = @import("../../../js/js.zig");
const EventTarget = @import("../../EventTarget.zig");
-const idb = @import("idb.zig");
const Key = @import("Key.zig");
const Engine = @import("Engine.zig");
const IDBTransaction = @import("IDBTransaction.zig");
const IDBObjectStore = @import("IDBObjectStore.zig");
const DOMStringList = @import("../../collections.zig").DOMStringList;
-const FunctionSetter = idb.FunctionSetter;
-
const Execution = js.Execution;
const Allocator = std.mem.Allocator;
@@ -45,8 +42,6 @@ _database_id: i64,
_name: []const u8,
_version: i64,
_txn: ?*IDBTransaction = null, // only set during upgradeneeded
-_on_error: ?js.Function.Global = null,
-_on_abort: ?js.Function.Global = null,
_closed: bool = false,
pub fn init(exec: *Execution, engine: *Engine, database_id: i64, name: []const u8, version: i64) !*IDBDatabase {
@@ -258,28 +253,6 @@ pub fn getObjectStoreNames(self: *IDBDatabase, exec: *Execution) !*DOMStringList
return list;
}
-fn getOnError(self: *const IDBDatabase) ?js.Function.Global {
- return self._on_error;
-}
-
-fn setOnError(self: *IDBDatabase, setter: ?FunctionSetter) void {
- self._on_error = if (setter) |s| switch (s) {
- .func => |f| f,
- .anything => null,
- } else null;
-}
-
-fn getOnAbort(self: *const IDBDatabase) ?js.Function.Global {
- return self._on_abort;
-}
-
-fn setOnAbort(self: *IDBDatabase, setter: ?FunctionSetter) void {
- self._on_abort = if (setter) |s| switch (s) {
- .func => |f| f,
- .anything => null,
- } else null;
-}
-
pub const JsApi = struct {
pub const bridge = js.Bridge(IDBDatabase);
@@ -296,6 +269,6 @@ pub const JsApi = struct {
pub const deleteObjectStore = bridge.function(IDBDatabase.deleteObjectStore, .{});
pub const transaction = bridge.function(IDBDatabase.transaction, .{});
pub const close = bridge.function(IDBDatabase.close, .{});
- pub const onerror = bridge.accessor(IDBDatabase.getOnError, IDBDatabase.setOnError, .{});
- pub const onabort = bridge.accessor(IDBDatabase.getOnAbort, IDBDatabase.setOnAbort, .{});
+ pub const onerror = EventTarget.handlerAccessor(IDBDatabase, "error");
+ pub const onabort = EventTarget.handlerAccessor(IDBDatabase, "abort");
};
diff --git a/src/browser/webapi/storage/idb/IDBOpenDBRequest.zig b/src/browser/webapi/storage/idb/IDBOpenDBRequest.zig
index 780b70291..fa86ec209 100644
--- a/src/browser/webapi/storage/idb/IDBOpenDBRequest.zig
+++ b/src/browser/webapi/storage/idb/IDBOpenDBRequest.zig
@@ -18,35 +18,18 @@
const js = @import("../../../js/js.zig");
-const idb = @import("idb.zig");
+const EventTarget = @import("../../EventTarget.zig");
const IDBRequest = @import("IDBRequest.zig");
-const FunctionSetter = idb.FunctionSetter;
-
// The request returned by IDBFactory.open / deleteDatabase.
const IDBOpenDBRequest = @This();
pub const Proto = IDBRequest;
_proto: *IDBRequest,
-// Stored, never fired: an open that upgrades does not wait on other
-// connections (see IDBFactory.OpenContext), so nothing ever blocks.
-_on_blocked: ?js.Function.Global = null,
-
-fn getOnBlocked(self: *const IDBOpenDBRequest) ?js.Function.Global {
- return self._on_blocked;
-}
-
-fn setOnBlocked(self: *IDBOpenDBRequest, setter: ?FunctionSetter) void {
- self._on_blocked = idb.functionFromSetter(setter);
-}
-
-fn getOnUpgradeNeeded(self: *const IDBOpenDBRequest) ?js.Function.Global {
- return self._proto.getOnUpgradeNeeded();
-}
-fn setOnUpgradeNeeded(self: *IDBOpenDBRequest, setter: ?FunctionSetter) void {
- self._proto.setOnUpgradeNeeded(setter);
+pub fn asEventTarget(self: *IDBOpenDBRequest) *EventTarget {
+ return self._proto.asEventTarget();
}
pub const JsApi = struct {
@@ -58,6 +41,6 @@ pub const JsApi = struct {
pub var class_id: bridge.ClassId = undefined;
};
- pub const onblocked = bridge.accessor(IDBOpenDBRequest.getOnBlocked, IDBOpenDBRequest.setOnBlocked, .{});
- pub const onupgradeneeded = bridge.accessor(IDBOpenDBRequest.getOnUpgradeNeeded, IDBOpenDBRequest.setOnUpgradeNeeded, .{});
+ pub const onblocked = EventTarget.handlerAccessor(IDBOpenDBRequest, "blocked");
+ pub const onupgradeneeded = EventTarget.handlerAccessor(IDBOpenDBRequest, "upgradeneeded");
};
diff --git a/src/browser/webapi/storage/idb/IDBRequest.zig b/src/browser/webapi/storage/idb/IDBRequest.zig
index 6dddeabdc..69514824f 100644
--- a/src/browser/webapi/storage/idb/IDBRequest.zig
+++ b/src/browser/webapi/storage/idb/IDBRequest.zig
@@ -38,7 +38,6 @@ const IDBVersionChangeEvent = @import("IDBVersionChangeEvent.zig");
const log = lp.log;
const Execution = js.Execution;
-const FunctionSetter = idb.FunctionSetter;
const IDBRequest = @This();
@@ -61,10 +60,6 @@ _result: Result = .{ .none = js.Undefined{} },
// it cannot be used
_result_owned: bool = false,
-_on_success: ?js.Function.Global = null,
-_on_error: ?js.Function.Global = null,
-_on_upgrade_needed: ?js.Function.Global = null,
-
const ReadyState = enum {
pending,
done,
@@ -232,7 +227,7 @@ pub fn fireUpgradeNeeded(self: *IDBRequest, exec: *Execution, old_version: u64,
event.asEvent().acquireRef();
defer _ = event.asEvent().releaseRef(exec.page);
- try exec.dispatch(self.asEventTarget(), event.asEvent(), self._on_upgrade_needed, .{ .context = "IDBRequest.upgradeneeded" });
+ try exec.dispatch(self.asEventTarget(), event.asEvent(), .{ .context = "IDBRequest.upgradeneeded" });
// A throwing listener aborts the upgrade (after every listener ran).
if (event.asEvent()._listeners_did_throw) {
@@ -254,7 +249,7 @@ pub fn fireSuccess(self: *IDBRequest, exec: *Execution) !void {
event.acquireRef();
defer event.releaseRef(exec.page);
- try exec.dispatch(self.asEventTarget(), event, self._on_success, .{ .context = "IDBRequest.success" });
+ try exec.dispatch(self.asEventTarget(), event, .{ .context = "IDBRequest.success" });
if (event._listeners_did_throw) blk: {
// if the event threw, we must abort
@@ -287,14 +282,14 @@ fn fireError(self: *IDBRequest, exec: *Execution) !void {
event._target = et;
event._dispatch_target = et;
- try exec.dispatch(et, event, self._on_error, .{ .context = "IDBRequest.error", .inject_target = false });
+ try exec.dispatch(et, event, .{ .context = "IDBRequest.error", .inject_target = false });
if (txn) |tx| {
if (!event._stop_propagation) {
- try exec.dispatch(tx.asEventTarget(), event, tx._on_error, .{ .context = "IDBTransaction.error", .inject_target = false });
+ try exec.dispatch(tx.asEventTarget(), event, .{ .context = "IDBTransaction.error", .inject_target = false });
}
if (!event._stop_propagation) {
const db = tx._db;
- try exec.dispatch(db.asEventTarget(), event, db._on_error, .{ .context = "IDBDatabase.error", .inject_target = false });
+ try exec.dispatch(db.asEventTarget(), event, .{ .context = "IDBDatabase.error", .inject_target = false });
}
// Don't re-abort a transaction that's already finishing — the AbortError
@@ -369,38 +364,6 @@ fn getError(self: *const IDBRequest) !?DOMException {
return DOMException.fromError(mapped) orelse DOMException.init(null, "UnknownError");
}
-fn getOnSuccess(self: *const IDBRequest) ?js.Function.Global {
- return self._on_success;
-}
-
-fn setOnSuccess(self: *IDBRequest, setter: ?FunctionSetter) void {
- self._on_success = getFunctionFromSetter(setter);
-}
-
-fn getOnError(self: *const IDBRequest) ?js.Function.Global {
- return self._on_error;
-}
-
-fn setOnError(self: *IDBRequest, setter: ?FunctionSetter) void {
- self._on_error = getFunctionFromSetter(setter);
-}
-
-pub fn getOnUpgradeNeeded(self: *const IDBRequest) ?js.Function.Global {
- return self._on_upgrade_needed;
-}
-
-pub fn setOnUpgradeNeeded(self: *IDBRequest, setter: ?FunctionSetter) void {
- self._on_upgrade_needed = getFunctionFromSetter(setter);
-}
-
-fn getFunctionFromSetter(setter: ?FunctionSetter) ?js.Function.Global {
- const s = setter orelse return null;
- return switch (s) {
- .func => |f| f,
- .anything => null,
- };
-}
-
// A database operation, captured when a request method is called and run later.
const Operation = union(enum) {
none,
@@ -510,6 +473,6 @@ pub const JsApi = struct {
pub const source = bridge.accessor(IDBRequest.getSource, null, .{});
pub const transaction = bridge.accessor(IDBRequest.getTransaction, null, .{});
pub const @"error" = bridge.accessor(IDBRequest.getError, null, .{});
- pub const onsuccess = bridge.accessor(IDBRequest.getOnSuccess, IDBRequest.setOnSuccess, .{});
- pub const onerror = bridge.accessor(IDBRequest.getOnError, IDBRequest.setOnError, .{});
+ pub const onsuccess = EventTarget.handlerAccessor(IDBRequest, "success");
+ pub const onerror = EventTarget.handlerAccessor(IDBRequest, "error");
};
diff --git a/src/browser/webapi/storage/idb/IDBTransaction.zig b/src/browser/webapi/storage/idb/IDBTransaction.zig
index 66ca64df3..e522064e4 100644
--- a/src/browser/webapi/storage/idb/IDBTransaction.zig
+++ b/src/browser/webapi/storage/idb/IDBTransaction.zig
@@ -35,7 +35,6 @@ const DOMStringList = @import("../../collections.zig").DOMStringList;
const log = lp.log;
const Execution = js.Execution;
-const FunctionSetter = idb.FunctionSetter;
const IDBTransaction = @This();
@@ -110,10 +109,6 @@ _cloning: bool = false,
// a pin (parked) or the drain task does (owner).
_parked: bool = false,
-_on_complete: ?js.Function.Global = null,
-_on_error: ?js.Function.Global = null,
-_on_abort: ?js.Function.Global = null,
-
pub const Mode = enum {
readonly,
readwrite,
@@ -410,14 +405,14 @@ fn fireAbort(self: *IDBTransaction, exec: *Execution) void {
const et = self.asEventTarget();
event._target = et;
event._dispatch_target = et;
- exec.dispatch(et, event, self._on_abort, .{ .context = "IDBTransaction.abort", .inject_target = false }) catch |err| {
+ exec.dispatch(et, event, .{ .context = "IDBTransaction.abort", .inject_target = false }) catch |err| {
log.debug(.storage, "idb abort dispatch", .{ .err = err });
};
if (event._stop_propagation) {
return;
}
const db = self._db;
- exec.dispatch(db.asEventTarget(), event, db._on_abort, .{ .context = "IDBDatabase.abort", .inject_target = false }) catch |err| {
+ exec.dispatch(db.asEventTarget(), event, .{ .context = "IDBDatabase.abort", .inject_target = false }) catch |err| {
log.debug(.storage, "idb abort dispatch", .{ .err = err });
};
}
@@ -479,7 +474,7 @@ fn commitAndComplete(self: *IDBTransaction, exec: *Execution) void {
self._begun = false;
}
_ = self._engine.releaseGate(&self._gate_waiter);
- self.fire(exec, comptime .wrap("complete"), self._on_complete);
+ self.fire(exec, comptime .wrap("complete"));
}
// "is this transaction still usable". Once settled or explicitly committing, it
@@ -602,45 +597,13 @@ fn getError(self: *const IDBTransaction) ?DOMException {
return DOMException.fromError(mapped) orelse DOMException.init(null, "UnknownError");
}
-fn getOnComplete(self: *const IDBTransaction) ?js.Function.Global {
- return self._on_complete;
-}
-
-fn setOnComplete(self: *IDBTransaction, setter: ?FunctionSetter) void {
- self._on_complete = getFunctionFromSetter(setter);
-}
-
-fn getOnError(self: *const IDBTransaction) ?js.Function.Global {
- return self._on_error;
-}
-
-fn setOnError(self: *IDBTransaction, setter: ?FunctionSetter) void {
- self._on_error = getFunctionFromSetter(setter);
-}
-
-fn getOnAbort(self: *const IDBTransaction) ?js.Function.Global {
- return self._on_abort;
-}
-
-fn setOnAbort(self: *IDBTransaction, setter: ?FunctionSetter) void {
- self._on_abort = getFunctionFromSetter(setter);
-}
-
-fn getFunctionFromSetter(setter: ?FunctionSetter) ?js.Function.Global {
- const s = setter orelse return null;
- return switch (s) {
- .func => |f| f,
- .anything => null,
- };
-}
-
-fn fire(self: *IDBTransaction, exec: *Execution, typ: lp.String, handler: ?js.Function.Global) void {
+fn fire(self: *IDBTransaction, exec: *Execution, typ: lp.String) void {
self._settled = true;
const event = Event.initTrusted(typ, null, exec.page) catch |err| {
log.debug(.storage, "idb transaction event", .{ .err = err });
return;
};
- exec.dispatch(self.asEventTarget(), event, handler, .{ .context = "IDBTransaction" }) catch |err| {
+ exec.dispatch(self.asEventTarget(), event, .{ .context = "IDBTransaction" }) catch |err| {
log.debug(.storage, "idb transaction dispatch", .{ .err = err });
};
}
@@ -823,7 +786,7 @@ pub const JsApi = struct {
pub const objectStore = bridge.function(IDBTransaction.objectStore, .{});
pub const abort = bridge.function(IDBTransaction.abort, .{});
pub const commit = bridge.function(IDBTransaction.commit, .{});
- pub const oncomplete = bridge.accessor(IDBTransaction.getOnComplete, IDBTransaction.setOnComplete, .{});
- pub const onerror = bridge.accessor(IDBTransaction.getOnError, IDBTransaction.setOnError, .{});
- pub const onabort = bridge.accessor(IDBTransaction.getOnAbort, IDBTransaction.setOnAbort, .{});
+ pub const oncomplete = EventTarget.handlerAccessor(IDBTransaction, "complete");
+ pub const onerror = EventTarget.handlerAccessor(IDBTransaction, "error");
+ pub const onabort = EventTarget.handlerAccessor(IDBTransaction, "abort");
};
diff --git a/src/browser/webapi/storage/idb/idb.zig b/src/browser/webapi/storage/idb/idb.zig
index 2bd2b3cd0..942443126 100644
--- a/src/browser/webapi/storage/idb/idb.zig
+++ b/src/browser/webapi/storage/idb/idb.zig
@@ -71,21 +71,6 @@ pub fn cachedKeyPathJs(cache: *?*js.GlobalSlot, txn: *IDBTransaction, kp: ?Key.K
return Key.keyPathToJs(local, kp);
}
-// An on* event-handler attribute setter. The bridge can hand the setter either
-// a function (store it) or any other value (clears it).
-pub const FunctionSetter = union(enum) {
- func: js.Function.Global,
- anything: js.Value,
-};
-
-pub fn functionFromSetter(setter: ?FunctionSetter) ?js.Function.Global {
- const s = setter orelse return null;
- return switch (s) {
- .func => |f| f,
- .anything => null,
- };
-}
-
const testing = @import("../../../../testing.zig");
test "WebApi: IndexedDB" {
try testing.htmlRunner("indexeddb.html", .{});
diff --git a/src/mcp/tools.zig b/src/mcp/tools.zig
index c19714073..0c7b890ee 100644
--- a/src/mcp/tools.zig
+++ b/src/mcp/tools.zig
@@ -1635,7 +1635,7 @@ test "MCP - findElement" {
\\{"jsonrpc":"2.0","id":1,"method":"tools/call","params":{"name":"findElement","arguments":{"role":"button"}}}
);
try testing.expectJson(.{
- .{ .name = "Click Me", .listeners = &.{ "pointerdown", "mousedown", "pointerup", "mouseup", "click" } },
+ .{ .name = "Click Me", .listeners = &.{ "click", "pointerdown", "mousedown", "pointerup", "mouseup" } },
.{ .name = "Prevent Default" },
.{ .name = "Chord" },
.{ .name = "Disabled", .disabled = true },
diff --git a/src/server/cdp/domains/emulation.zig b/src/server/cdp/domains/emulation.zig
index 65fda606d..b2e486b90 100644
--- a/src/server/cdp/domains/emulation.zig
+++ b/src/server/cdp/domains/emulation.zig
@@ -293,7 +293,7 @@ test "cdp.Emulation: viewport override fires matchMedia change events" {
var ls: js.Local.Scope = undefined;
frame.js.localScope(&ls);
defer ls.deinit();
- const v = try ls.local.exec("events.join() === 'onchange:(max-width: 500px),listener:true,onchange:(max-width: 500px),listener:false'", null);
+ const v = try ls.local.exec("events.join() === 'listener:true,onchange:(max-width: 500px),listener:false,onchange:(max-width: 500px)'", null);
try testing.expect(v.toBool());
}