diff --git a/src/browser/dom/event_target.zig b/src/browser/dom/event_target.zig index e34e3690..acb6e934 100644 --- a/src/browser/dom/event_target.zig +++ b/src/browser/dom/event_target.zig @@ -41,68 +41,14 @@ pub const EventTarget = struct { // JS funcs // -------- - - const AddEventListenerOpts = union(enum) { - opts: Opts, - capture: bool, - - const Opts = struct { - capture: ?bool, - // We ignore this property. It seems to be largely used to help the - // browser make certain performance tweaks (i.e. the browser knows - // that the listener won't call preventDefault() and thus can safely - // run the default as needed). - passive: ?bool, - once: ?bool, // currently does nothing - signal: ?bool, // currently does nothing - }; - }; - pub fn _addEventListener( self: *parser.EventTarget, typ: []const u8, listener: EventHandler.Listener, - opts_: ?AddEventListenerOpts, + opts: ?EventHandler.Opts, page: *Page, ) !void { - var capture = false; - if (opts_) |opts| { - switch (opts) { - .capture => |c| capture = c, - .opts => |o| { - // Done this way so that, for common cases that _only_ set - // capture, i.e. {captrue: true}, it works. - // But for any case that sets any of the other flags, we - // error. If we don't error, this function call would succeed - // but the behavior might be wrong. At this point, it's - // better to be explicit and error. - if (o.once orelse false) return error.NotImplemented; - if (o.signal orelse false) return error.NotImplemented; - capture = o.capture orelse false; - }, - } - } - - const cbk = (try listener.callback(self)) orelse return; - - // check if event target has already this listener - const lst = try parser.eventTargetHasListener( - self, - typ, - capture, - cbk.id, - ); - if (lst != null) { - return; - } - const eh = try EventHandler.init(page.arena, cbk); - - try parser.eventTargetAddEventListener( - self, - typ, - &eh.node, - capture, - ); + _ = try EventHandler.register(page.arena, self, typ, listener, opts); } const RemoveEventListenerOpts = union(enum) { diff --git a/src/browser/dom/mutation_observer.zig b/src/browser/dom/mutation_observer.zig index c4deff88..c651c851 100644 --- a/src/browser/dom/mutation_observer.zig +++ b/src/browser/dom/mutation_observer.zig @@ -63,13 +63,13 @@ pub const MutationObserver = struct { // register node's events if (options.childList or options.subtree) { - try parser.eventTargetAddEventListener( + _ = try parser.eventTargetAddEventListener( parser.toEventTarget(parser.Node, node), "DOMNodeInserted", &observer.event_node, false, ); - try parser.eventTargetAddEventListener( + _ = try parser.eventTargetAddEventListener( parser.toEventTarget(parser.Node, node), "DOMNodeRemoved", &observer.event_node, @@ -77,7 +77,7 @@ pub const MutationObserver = struct { ); } if (options.attr()) { - try parser.eventTargetAddEventListener( + _ = try parser.eventTargetAddEventListener( parser.toEventTarget(parser.Node, node), "DOMAttrModified", &observer.event_node, @@ -85,7 +85,7 @@ pub const MutationObserver = struct { ); } if (options.cdata()) { - try parser.eventTargetAddEventListener( + _ = try parser.eventTargetAddEventListener( parser.toEventTarget(parser.Node, node), "DOMCharacterDataModified", &observer.event_node, @@ -93,7 +93,7 @@ pub const MutationObserver = struct { ); } if (options.subtree) { - try parser.eventTargetAddEventListener( + _ = try parser.eventTargetAddEventListener( parser.toEventTarget(parser.Node, node), "DOMSubtreeModified", &observer.event_node, diff --git a/src/browser/events/event.zig b/src/browser/events/event.zig index f4fddcfa..1dc7c422 100644 --- a/src/browser/events/event.zig +++ b/src/browser/events/event.zig @@ -138,8 +138,11 @@ pub const Event = struct { }; pub const EventHandler = struct { + once: bool, + capture: bool, callback: Function, node: parser.EventNode, + listener: *parser.EventListener, const Env = @import("../env.zig").Env; const Function = Env.Function; @@ -159,15 +162,73 @@ pub const EventHandler = struct { } }; - pub fn init(allocator: Allocator, callback: Function) !*EventHandler { + pub const Opts = union(enum) { + flags: Flags, + capture: bool, + + const Flags = struct { + once: ?bool, + capture: ?bool, + // We ignore this property. It seems to be largely used to help the + // browser make certain performance tweaks (i.e. the browser knows + // that the listener won't call preventDefault() and thus can safely + // run the default as needed). + passive: ?bool, + signal: ?bool, // currently does nothing + }; + }; + + pub fn register( + allocator: Allocator, + target: *parser.EventTarget, + typ: []const u8, + listener: Listener, + opts_: ?Opts, + ) !?*EventHandler { + var once = false; + var capture = false; + if (opts_) |opts| { + switch (opts) { + .capture => |c| capture = c, + .flags => |f| { + // Done this way so that, for common cases that _only_ set + // capture, i.e. {captrue: true}, it works. + // But for any case that sets any of the other flags, we + // error. If we don't error, this function call would succeed + // but the behavior might be wrong. At this point, it's + // better to be explicit and error. + if (f.signal orelse false) return error.NotImplemented; + once = f.once orelse false; + capture = f.capture orelse false; + }, + } + } + + const callback = (try listener.callback(target)) orelse return null; + + // check if event target has already this listener + if (try parser.eventTargetHasListener(target, typ, capture, callback.id) != null) { + return null; + } + const eh = try allocator.create(EventHandler); eh.* = .{ + .once = once, + .capture = capture, .callback = callback, .node = .{ .id = callback.id, .func = handle, }, + .listener = undefined, }; + + eh.listener = try parser.eventTargetAddEventListener( + target, + typ, + &eh.node, + capture, + ); return eh; } @@ -182,6 +243,17 @@ pub const EventHandler = struct { self.callback.tryCall(void, .{ievent}, &result) catch { log.debug(.event, "handle callback error", .{ .err = result.exception, .stack = result.stack }); }; + + if (self.once) { + const target = (parser.eventTarget(event) catch return).?; + const typ = parser.eventType(event) catch return; + parser.eventTargetRemoveEventListener( + target, + typ, + self.listener, + self.capture, + ) catch {}; + } } }; @@ -282,4 +354,13 @@ test "Browser.Event" { .{ "document.dispatchEvent(new Event('count'))", "true" }, .{ "nb", "0" }, }, .{}); + + try runner.testCases(&.{ + .{ "nb = 0; function cbk(event) { nb ++; }", null }, + .{ "document.addEventListener('count', cbk, {once: true})", null }, + .{ "document.dispatchEvent(new Event('count'))", "true" }, + .{ "document.dispatchEvent(new Event('count'))", "true" }, + .{ "document.dispatchEvent(new Event('count'))", "true" }, + .{ "nb", "1" }, + }, .{}); } diff --git a/src/browser/netsurf.zig b/src/browser/netsurf.zig index 756d8fb6..d83a6a85 100644 --- a/src/browser/netsurf.zig +++ b/src/browser/netsurf.zig @@ -615,7 +615,7 @@ pub fn eventTargetAddEventListener( typ: []const u8, node: *EventNode, capture: bool, -) !void { +) !*EventListener { const event_handler = struct { fn handle(event_: ?*Event, ptr_: ?*anyopaque) callconv(.C) void { const ptr = ptr_ orelse return; @@ -634,6 +634,8 @@ pub fn eventTargetAddEventListener( const s = try strFromData(typ); const err = eventTargetVtable(et).add_event_listener.?(et, s, listener, capture); try DOMErr(err); + + return listener.?; } pub fn eventTargetHasListener( diff --git a/src/browser/page.zig b/src/browser/page.zig index e5ac0d38..39a5279c 100644 --- a/src/browser/page.zig +++ b/src/browser/page.zig @@ -273,7 +273,7 @@ pub const Page = struct { const doc = parser.documentHTMLToDocument(html_doc); const document_element = (try parser.documentGetDocumentElement(doc)) orelse return error.DocumentElementError; - try parser.eventTargetAddEventListener( + _ = try parser.eventTargetAddEventListener( parser.toEventTarget(parser.Element, document_element), "click", &self.window_clicked_event_node, diff --git a/src/browser/xhr/event_target.zig b/src/browser/xhr/event_target.zig index 57afd2bf..8f4b9e28 100644 --- a/src/browser/xhr/event_target.zig +++ b/src/browser/xhr/event_target.zig @@ -48,17 +48,14 @@ pub const XMLHttpRequestEventTarget = struct { ) !?Function { const target = @as(*parser.EventTarget, @ptrCast(self)); - const callback = (try listener.callback(target)) orelse return null; - const eh = try EventHandler.init(alloc, callback); - try parser.eventTargetAddEventListener( - target, - typ, - &eh.node, - false, - ); - - return callback; + // The only time this can return null if the listener is already + // registered. But before calling `register`, all of our functions + // remove any existing listener, so it should be impossible to get null + // from this function call. + const eh = (try EventHandler.register(alloc, target, typ, listener, null)) orelse unreachable; + return eh.callback; } + fn unregister(self: *XMLHttpRequestEventTarget, typ: []const u8, cbk_id: usize) !void { const et = @as(*parser.EventTarget, @ptrCast(self)); // check if event target has already this listener