Skip to content

Lightpanda: the headless browser designed for AI and automation

Use Window frame to set click listener, not invocation frame

Karl Seguin54ae8800b2fd
diff --git a/src/browser/EventManager.zig b/src/browser/EventManager.zig
index 0ac74e2fa..7cffc2d79 100644
--- a/src/browser/EventManager.zig
+++ b/src/browser/EventManager.zig
@@ -28,6 +28,7 @@ const Node = @import("webapi/Node.zig");
const Event = @import("webapi/Event.zig");
const EventTarget = @import("webapi/EventTarget.zig");
const Element = @import("webapi/Element.zig");
+const ShadowRoot = @import("webapi/ShadowRoot.zig");
const log = lp.log;
const Allocator = std.mem.Allocator;
@@ -111,9 +112,6 @@ pub fn dispatchOpts(self: *EventManager, target: *EventTarget, event: *Event, co
switch (target._type) {
.node => |node| try self.dispatchNode(node, event, opts),
- // Property event handlers (e.g. xhr.onload, window.onerror) fire for
- // script-dispatched events too, not only for the internal dispatch
- // paths which pass them explicitly.
.xhr => |xhr| try self.dispatchDirect(target, event, xhr.inlineHandler(event._type_string), .{ .context = "dispatch" }),
.window => |w| try self.dispatchDirect(target, event, windowInlineHandler(w, event._type_string), .{ .context = "dispatch" }),
else => try self.dispatchDirect(target, event, null, .{ .context = "dispatch" }),
@@ -164,8 +162,6 @@ pub fn hasDirectListeners(self: *EventManager, target: *EventTarget, typ: []cons
}
fn dispatchNode(self: *EventManager, target: *Node, event: *Event, comptime opts: DispatchOpts) !void {
- const ShadowRoot = @import("webapi/ShadowRoot.zig");
-
{
const et = target.asEventTarget();
event._target = et;
@@ -388,20 +384,8 @@ fn dispatchNode(self: *EventManager, target: *Node, event: *Event, comptime opts
}
}
-// 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 {
- const ShadowRoot = @import("webapi/ShadowRoot.zig");
- switch (target._type) {
- .node => |n| {
- const root = n.getRootNode(.{});
- if (root.is(ShadowRoot) != null) {
- return null;
- }
- },
- else => {},
- }
- return event;
+ return if (rootIsShadowRoot(target)) null else event;
}
const DispatchPhaseOpts = struct {
@@ -549,8 +533,6 @@ fn getInlineHandler(self: *EventManager, target: *EventTarget, event: *Event) ?j
// DOM spec "retarget": walk original_target out of shadow trees until the
// node is visible from current_target's tree.
fn getAdjustedTarget(original_target: ?*EventTarget, current_target: *EventTarget) ?*EventTarget {
- const ShadowRoot = @import("webapi/ShadowRoot.zig");
-
const orig_node = switch ((original_target orelse return null)._type) {
.node => |n| n,
else => return original_target,
@@ -572,8 +554,6 @@ fn getAdjustedTarget(original_target: ?*EventTarget, current_target: *EventTarge
}
fn isShadowIncludingInclusiveAncestor(ancestor: *Node, node: *Node) bool {
- const ShadowRoot = @import("webapi/ShadowRoot.zig");
-
var n: ?*Node = node;
while (n) |cur| {
if (cur == ancestor) {
@@ -591,8 +571,6 @@ fn isShadowIncludingInclusiveAncestor(ancestor: *Node, node: *Node) bool {
// Whether the target's tree root (without crossing shadow boundaries) is a
// shadow root. Used for the spec's post-dispatch "clear targets" step.
fn rootIsShadowRoot(target_: ?*EventTarget) bool {
- const ShadowRoot = @import("webapi/ShadowRoot.zig");
-
const target = target_ orelse return false;
var current: *Node = switch (target._type) {
.node => |n| n,
diff --git a/src/browser/webapi/Document.zig b/src/browser/webapi/Document.zig
index e3b711b7f..10548f3b8 100644
--- a/src/browser/webapi/Document.zig
+++ b/src/browser/webapi/Document.zig
@@ -94,14 +94,15 @@ pub fn setOnSelectionChange(self: *Document, listener: ?js.Function) !void {
// property handlers), which the dispatch propagation path consults for any
// event target.
pub fn getOnClick(self: *Document, frame: *Frame) ?js.Function.Global {
- return frame._event_target_attr_listeners.get(.{ .target = self.asEventTarget(), .handler = .onclick });
+ return (self._frame orelse frame)._event_target_attr_listeners.get(.{ .target = self.asEventTarget(), .handler = .onclick });
}
pub fn setOnClick(self: *Document, setter: ?Window.FunctionSetter, frame: *Frame) !void {
+ const owner = self._frame orelse frame;
if (Window.getFunctionFromSetter(setter)) |cb| {
- try frame._event_target_attr_listeners.put(frame.arena, .{ .target = self.asEventTarget(), .handler = .onclick }, cb);
+ try owner._event_target_attr_listeners.put(owner.arena, .{ .target = self.asEventTarget(), .handler = .onclick }, cb);
} else {
- _ = frame._event_target_attr_listeners.remove(.{ .target = self.asEventTarget(), .handler = .onclick });
+ _ = owner._event_target_attr_listeners.remove(.{ .target = self.asEventTarget(), .handler = .onclick });
}
}
diff --git a/src/browser/webapi/Event.zig b/src/browser/webapi/Event.zig
index b4207be2a..298370fc7 100644
--- a/src/browser/webapi/Event.zig
+++ b/src/browser/webapi/Event.zig
@@ -107,15 +107,6 @@ pub fn init(typ: []const u8, opts_: ?Options, page: *Page) !*Event {
return initWithTrusted(arena, str, opts_, false);
}
-// The JS constructor entry point: also captures the creating realm's time
-// origin so timeStamp stays relative to the event's relevant global even
-// when read from another realm.
-fn initFromJs(typ: []const u8, opts_: ?Options, exec: *js.Execution) !*Event {
- const event = try init(typ, opts_, exec.page);
- event._time_origin = exec.performance()._time_origin;
- return event;
-}
-
pub fn initTrusted(typ: String, opts_: ?Options, page: *Page) !*Event {
const arena = try page.getArena(.tiny, "Event.trusted");
errdefer page.releaseArena(arena);
@@ -274,10 +265,6 @@ pub fn getEventPhase(self: *const Event) u8 {
return @intFromEnum(self._event_phase);
}
-// A DOMHighResTimeStamp in milliseconds, relative to the relevant global's
-// time origin (the same clock as performance.now()). When the creating
-// realm's origin wasn't captured, fall back to the accessing realm's, which
-// is the same realm in all but cross-realm accesses.
pub fn getTimeStamp(self: *const Event, exec: *js.Execution) f64 {
const origin = if (self._time_origin != 0) self._time_origin else exec.performance()._time_origin;
if (self._time_stamp <= origin) {
@@ -495,7 +482,14 @@ pub const JsApi = struct {
pub var class_id: bridge.ClassId = undefined;
};
- pub const constructor = bridge.constructor(Event.initFromJs, .{});
+ pub const constructor = bridge.constructor(struct {
+ fn wrap(typ: []const u8, opts_: ?Options, exec: *js.Execution) !*Event {
+ const event = try Event.init(typ, opts_, exec.page);
+ // capture the realm's time
+ event._time_origin = exec.performance()._time_origin;
+ return event;
+ }
+ }.wrap, .{});
pub const @"type" = bridge.accessor(Event.getType, null, .{});
pub const bubbles = bridge.accessor(Event.getBubbles, null, .{});
pub const cancelable = bridge.accessor(Event.getCancelable, null, .{});
diff --git a/src/browser/webapi/EventTarget.zig b/src/browser/webapi/EventTarget.zig
index e8422f99c..ce130a143 100644
--- a/src/browser/webapi/EventTarget.zig
+++ b/src/browser/webapi/EventTarget.zig
@@ -69,8 +69,7 @@ pub fn dispatchEvent(self: *EventTarget, event: *Event, exec: *js.Execution) !bo
if (event._event_phase != .none) {
return error.InvalidStateError;
}
- // An event created by document.createEvent stays uninitialized until an
- // init*Event call; dispatching it is an error.
+
if (!event._initialized) {
return error.InvalidStateError;
}
diff --git a/src/browser/webapi/Window.zig b/src/browser/webapi/Window.zig
index b83f10ee5..c42f1da6a 100644
--- a/src/browser/webapi/Window.zig
+++ b/src/browser/webapi/Window.zig
@@ -428,15 +428,15 @@ pub fn setOnScroll(self: *Window, setter: ?FunctionSetter) void {
// Stored in the frame's attribute-listener map (like element and ShadowRoot
// property handlers), which the dispatch propagation path consults for any
// event target.
-pub fn getOnClick(self: *Window, frame: *Frame) ?js.Function.Global {
- return frame._event_target_attr_listeners.get(.{ .target = self.asEventTarget(), .handler = .onclick });
+pub fn getOnClick(self: *Window) ?js.Function.Global {
+ return self._frame._event_target_attr_listeners.get(.{ .target = self.asEventTarget(), .handler = .onclick });
}
-pub fn setOnClick(self: *Window, setter: ?FunctionSetter, frame: *Frame) !void {
+pub fn setOnClick(self: *Window, setter: ?FunctionSetter) !void {
if (getFunctionFromSetter(setter)) |cb| {
- try frame._event_target_attr_listeners.put(frame.arena, .{ .target = self.asEventTarget(), .handler = .onclick }, cb);
+ try self._frame._event_target_attr_listeners.put(self._frame.arena, .{ .target = self.asEventTarget(), .handler = .onclick }, cb);
} else {
- _ = frame._event_target_attr_listeners.remove(.{ .target = self.asEventTarget(), .handler = .onclick });
+ _ = self._frame._event_target_attr_listeners.remove(.{ .target = self.asEventTarget(), .handler = .onclick });
}
}