Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: Escape closes the topmost modal dialog

zxzinne280697cf61f
diff --git a/src/browser/frame/user_input.zig b/src/browser/frame/user_input.zig
index 6d1b6bbc9..4bce6647d 100644
--- a/src/browser/frame/user_input.zig
+++ b/src/browser/frame/user_input.zig
@@ -1560,6 +1560,10 @@ pub fn handleKeydown(frame: *Frame, target: *Node, event: *Event) !void {
return moveFocus(frame, keyboard_event.getShiftKey() == false);
}
+ if (key == .Escape) {
+ return Element.Html.Dialog.requestCloseTopModal(frame);
+ }
+
if (key == .Enter) {
if (target.is(Element)) |element| {
if (enterFollowsLink(element)) {
diff --git a/src/browser/tests/element/html/dialog_close_request.html b/src/browser/tests/element/html/dialog_close_request.html
new file mode 100644
index 000000000..6edb96d32
--- /dev/null
+++ b/src/browser/tests/element/html/dialog_close_request.html
@@ -0,0 +1,41 @@
+<!DOCTYPE html>
+<body>
+<dialog id="a">a</dialog>
+<dialog id="b">b</dialog>
+<script>
+ // Driven by the "HTML.Dialog close request" test in Dialog.zig, which
+ // presses a trusted Escape between steps.
+ window.A = document.getElementById('a');
+ window.B = document.getElementById('b');
+ window.log = [];
+ window.preventCancel = false;
+ window.preventKeydown = false;
+
+ for (const d of [A, B]) {
+ for (const type of ['cancel', 'close']) {
+ d.addEventListener(type, (e) => {
+ // A trailing "!" marks an event that was not cancelable.
+ log.push(`${type}@${d.id}${e.cancelable ? '' : '!'}`);
+ if (type === 'cancel' && preventCancel) e.preventDefault();
+ });
+ }
+ }
+ document.addEventListener('keydown', (e) => {
+ if (preventKeydown) e.preventDefault();
+ });
+
+ window.reset = () => {
+ for (const d of [A, B]) {
+ if (!d.isConnected) document.body.append(d);
+ d.close();
+ d.returnValue = '';
+ }
+ preventCancel = false;
+ preventKeydown = false;
+ log.length = 0;
+ };
+
+ window.state = () =>
+ `a:${A.open} b:${B.open} rv:${A.returnValue}|${B.returnValue} log:${log.join(',')}`;
+</script>
+</body>
diff --git a/src/browser/webapi/Document.zig b/src/browser/webapi/Document.zig
index 9c4614289..5be21ed30 100644
--- a/src/browser/webapi/Document.zig
+++ b/src/browser/webapi/Document.zig
@@ -100,6 +100,9 @@ _extent: ?struct {
} = null,
// Ordered stack of currently-showing popovers
_open_popovers: std.ArrayList(*Element) = .empty,
+// Ordered stack of dialogs opened with showModal(), topmost last. Stands in
+// for the top layer and the close watchers those dialogs establish.
+_modal_dialogs: std.ArrayList(*Element) = .empty,
// https://html.spec.whatwg.org/multipage/dynamic-markup-insertion.html#throw-on-dynamic-markup-insertion-counter
// Incremented during custom element reactions when parsing. When > 0,
@@ -1281,6 +1284,7 @@ pub fn open(self: *Document, call_frame: *Frame) !*Document {
self._elements_by_id.clearAndFree(frame.page_arena);
self.setActiveElement(null, frame);
self._open_popovers = .empty;
+ self._modal_dialogs = .empty;
self._style_sheets = null;
self._implementation = null;
self._ready_state = .loading;
diff --git a/src/browser/webapi/element/html/Dialog.zig b/src/browser/webapi/element/html/Dialog.zig
index c68565faa..25bf43a0a 100644
--- a/src/browser/webapi/element/html/Dialog.zig
+++ b/src/browser/webapi/element/html/Dialog.zig
@@ -28,6 +28,7 @@ const Element = @import("../../Element.zig");
const HtmlElement = @import("../Html.zig");
+const String = lp.String;
const Dialog = @This();
pub const Proto = HtmlElement;
@@ -61,6 +62,39 @@ pub fn show(self: *Dialog, frame: *Frame) !void {
fn showModal(self: *Dialog, frame: *Frame) !void {
if (self.getOpen()) return error.InvalidStateError;
try self.asElement().setAttributeSafe(comptime .wrap("open"), .wrap(""), frame);
+ // Only a connected dialog joins its document's top layer.
+ if (self.asNode().isConnected()) {
+ try frame.document._modal_dialogs.append(frame.page_arena, self.asElement());
+ }
+}
+
+/// https://html.spec.whatwg.org/multipage/interactive-elements.html#close-requests
+/// Escape's close request, handled by the topmost modal dialog's close
+/// watcher: fire `cancel` and, unless a listener cancels it, close the dialog
+/// without changing returnValue. Chrome makes `cancel` cancelable only with
+/// history-action user activation; that isn't tracked, so it always is.
+pub fn requestCloseTopModal(frame: *Frame) !void {
+ const stack = frame.document._modal_dialogs.items;
+ if (stack.len == 0) return;
+ const el = stack[stack.len - 1];
+ const dialog = el.is(Dialog) orelse return;
+
+ const event = try Event.init("cancel", .{ .bubbles = false, .cancelable = true }, frame.page);
+ if (try frame._event_manager.dispatchCancelable(el.asEventTarget(), event)) {
+ return;
+ }
+ // A cancel listener may already have closed it; close() is then a no-op.
+ try dialog.close(null, frame);
+}
+
+fn removeModal(el: *Element, frame: *Frame) void {
+ const list = &frame.document._modal_dialogs;
+ for (list.items, 0..) |item, i| {
+ if (item == el) {
+ _ = list.orderedRemove(i);
+ return;
+ }
+ }
}
/// https://html.spec.whatwg.org/multipage/interactive-elements.html#dom-dialog-close
@@ -80,6 +114,20 @@ pub fn getOpen(self: *const Dialog) bool {
return self.asConstElement().getAttributeSafe(comptime .wrap("open")) != null;
}
+// The dialog cleanup steps: a dialog that loses [open] (close() included) or
+// leaves the document stops being modal.
+pub const Build = struct {
+ pub fn attributeRemove(element: *Element, name: String, frame: *Frame) !void {
+ if (name.eql(comptime .wrap("open"))) {
+ removeModal(element, frame);
+ }
+ }
+
+ pub fn disconnected(element: *Element, frame: *Frame) !void {
+ removeModal(element, frame);
+ }
+};
+
pub const JsApi = struct {
pub const bridge = js.Bridge(Dialog);
@@ -102,3 +150,48 @@ const testing = @import("../../../../testing.zig");
test "WebApi: HTML.Dialog" {
try testing.htmlRunner("element/html/dialog.html", .{});
}
+
+test "WebApi: HTML.Dialog close request" {
+ const keyboard = @import("../../../frame/keyboard.zig");
+
+ const page = try testing.pageTest("element/html/dialog_close_request.html", .{});
+ defer page.close();
+ const frame = page.frame().?;
+ var ls: js.Local.Scope = undefined;
+ frame.js.localScope(&ls);
+ defer ls.deinit();
+
+ // Each step runs its script, presses a trusted Escape when `press` is set,
+ // then compares the page's state() summary.
+ const steps = [_]struct { []const u8, bool, []const u8 }{
+ // The modal dialog closes; returnValue is left unchanged.
+ .{ "reset(); A.returnValue = 'keep'; A.showModal()", true, "a:false b:false rv:keep| log:cancel@a,close@a!" },
+ // Only the topmost modal closes, then the one below it.
+ .{ "reset(); A.showModal(); B.showModal()", true, "a:true b:false rv:| log:cancel@b,close@b!" },
+ .{ "", true, "a:false b:false rv:| log:cancel@b,close@b!,cancel@a,close@a!" },
+ // Cancelling `cancel` keeps the dialog open.
+ .{ "reset(); A.showModal(); preventCancel = true", true, "a:true b:false rv:| log:cancel@a" },
+ // Cancelling the keydown stops the close request entirely.
+ .{ "reset(); A.showModal(); preventKeydown = true", true, "a:true b:false rv:| log:" },
+ // A dialog opened with show() has no close watcher.
+ .{ "reset(); A.show()", true, "a:true b:false rv:| log:" },
+ // An untrusted keydown has no default action.
+ .{ "reset(); A.showModal(); document.body.dispatchEvent(new KeyboardEvent('keydown', { key: 'Escape', bubbles: true }))", false, "a:true b:false rv:| log:" },
+ // Removing [open] or the dialog itself takes it out of the stack.
+ .{ "reset(); A.showModal(); B.showModal(); B.removeAttribute('open')", true, "a:false b:false rv:| log:cancel@a,close@a!" },
+ .{ "reset(); A.showModal(); B.showModal(); B.remove()", true, "a:false b:true rv:| log:cancel@a,close@a!" },
+ // With no modal dialog, Escape does nothing.
+ .{ "reset()", true, "a:false b:false rv:| log:" },
+ };
+ const escape = keyboard.named("Escape");
+ for (steps) |step| {
+ const script, const press, const expected = step;
+ _ = try ls.local.compileAndRun(script, null);
+ if (press) {
+ try keyboard.dispatch(frame, null, .down, &escape, &.{});
+ try keyboard.dispatch(frame, null, .up, &escape, &.{});
+ }
+ const actual = try (try ls.local.compileAndRun("state()", null)).toStringSliceWithAlloc(testing.arena_allocator);
+ try testing.expectString(expected, actual);
+ }
+}