Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: move the text entry cursor on caret movement keys

Navid EMADed2a5c6eeb58
diff --git a/src/browser/frame/user_input.zig b/src/browser/frame/user_input.zig
index 46c08d3d4..58f75decb 100644
--- a/src/browser/frame/user_input.zig
+++ b/src/browser/frame/user_input.zig
@@ -634,7 +634,7 @@ pub fn handleKeydown(frame: *Frame, target: *Node, event: *Event) !void {
return;
}
- return editKey(frame, event, input, key);
+ return editKey(frame, keyboard_event, input, key);
}
if (target.is(Element.Html.TextArea)) |textarea| {
@@ -645,12 +645,22 @@ pub fn handleKeydown(frame: *Frame, target: *Node, event: *Event) !void {
return;
}
- return editKey(frame, event, textarea, key);
+ return editKey(frame, keyboard_event, textarea, key);
}
}
// edit keys are handled by Input and TextArea the same
-fn editKey(frame: *Frame, event: *Event, ctl: anytype, key: KeyboardEvent.Key) !void {
+fn editKey(frame: *Frame, keyboard_event: *KeyboardEvent, ctl: anytype, key: KeyboardEvent.Key) !void {
+ const event = keyboard_event.asEvent();
+
+ if (caretMove(key, ctl)) |move| {
+ // Word/paragraph motions (ctrl/alt/meta variants) aren't modeled.
+ if (keyboard_event.getCtrlKey() or keyboard_event.getAltKey() or keyboard_event.getMetaKey()) {
+ return;
+ }
+ return ctl.moveCaret(move, keyboard_event.getShiftKey(), frame);
+ }
+
if (key == .Backspace or key == .Delete) {
const forward = key == .Delete;
if (try allowEdit(frame, event, ctl.asElement(), null, null, deleteInputType(forward))) {
@@ -666,6 +676,21 @@ fn editKey(frame: *Frame, event: *Event, ctl: anytype, key: KeyboardEvent.Key) !
}
}
+// Caret movement a key's default action performs on `ctl`, if any. On a
+// single-line <input> ArrowUp/ArrowDown go to the ends of the value, as in
+// Chrome; on a <textarea> they would need line geometry, so they do nothing.
+fn caretMove(key: KeyboardEvent.Key, ctl: anytype) ?@TypeOf(ctl.*).CaretMove {
+ return switch (key) {
+ .ArrowLeft => .backward,
+ .ArrowRight => .forward,
+ .Home => .line_start,
+ .End => .line_end,
+ .ArrowUp => if (@TypeOf(ctl) == *Element.Html.Input) .line_start else null,
+ .ArrowDown => if (@TypeOf(ctl) == *Element.Html.Input) .line_end else null,
+ else => null,
+ };
+}
+
fn deleteInputType(forward: bool) []const u8 {
return if (forward) "deleteContentForward" else "deleteContentBackward";
}
diff --git a/src/browser/webapi/element/html/Input.zig b/src/browser/webapi/element/html/Input.zig
index 6362ce460..a01008c18 100644
--- a/src/browser/webapi/element/html/Input.zig
+++ b/src/browser/webapi/element/html/Input.zig
@@ -623,6 +623,8 @@ const entry = text_entry.TextEntry(Input);
pub const select = entry.select;
pub const innerInsert = entry.innerInsert;
pub const innerDelete = entry.innerDelete;
+pub const moveCaret = entry.moveCaret;
+pub const CaretMove = entry.CaretMove;
pub const getSelectionDirection = entry.getSelectionDirection;
pub const setSelectionStart = entry.setSelectionStart;
pub const setSelectionEnd = entry.setSelectionEnd;
diff --git a/src/browser/webapi/element/html/TextArea.zig b/src/browser/webapi/element/html/TextArea.zig
index fc482551f..596f84a00 100644
--- a/src/browser/webapi/element/html/TextArea.zig
+++ b/src/browser/webapi/element/html/TextArea.zig
@@ -141,6 +141,8 @@ const entry = text_entry.TextEntry(TextArea);
pub const select = entry.select;
pub const innerInsert = entry.innerInsert;
pub const innerDelete = entry.innerDelete;
+pub const moveCaret = entry.moveCaret;
+pub const CaretMove = entry.CaretMove;
pub const getSelectionDirection = entry.getSelectionDirection;
pub const setSelectionStart = entry.setSelectionStart;
pub const setSelectionEnd = entry.setSelectionEnd;
diff --git a/src/browser/webapi/element/text_entry.zig b/src/browser/webapi/element/text_entry.zig
index cfe4d8005..c9c39cf95 100644
--- a/src/browser/webapi/element/text_entry.zig
+++ b/src/browser/webapi/element/text_entry.zig
@@ -69,10 +69,20 @@ pub fn TextEntry(comptime T: type) type {
try dispatchSelectionChangeEvent(self, frame);
},
.none => {
- // nothing selected, just insert at cursor.
+ // nothing selected, insert at the caret. Controls without
+ // selection support keep no caret; append.
const current_value = self.getValue();
- const new_value = try std.mem.concat(arena, u8, &.{ current_value, str });
+ const caret = if (self.selectionAvailable()) @min(self._selection_start, current_value.len) else current_value.len;
+ const new_value = try std.mem.concat(arena, u8, &.{ current_value[0..caret], str, current_value[caret..] });
try self.setUserValue(new_value, frame);
+ if (self.selectionAvailable()) {
+ // the sanitized value can be shorter than what was inserted
+ const new_pos: u32 = @intCast(@min(caret + str.len, self.getValue().len));
+ self._selection_start = new_pos;
+ self._selection_end = new_pos;
+ self._selection_direction = .none;
+ try dispatchSelectionChangeEvent(self, frame);
+ }
},
}
try dispatchInputEvent(self, str, "insertText", frame);
@@ -128,6 +138,85 @@ pub fn TextEntry(comptime T: type) type {
try dispatchInputEvent(self, null, if (forward) "deleteContentForward" else "deleteContentBackward", frame);
}
+ pub const CaretMove = enum { backward, forward, line_start, line_end };
+
+ // Default action of the caret movement keys (ArrowLeft, ArrowRight,
+ // Home, End). With `extend` (Shift held) the selection's focus moves
+ // and its anchor stays; otherwise the selection collapses. A plain
+ // ArrowLeft/ArrowRight on a non-collapsed selection collapses it to
+ // the corresponding edge without moving, like Chrome.
+ pub fn moveCaret(self: *T, move: CaretMove, extend: bool, frame: *Frame) !void {
+ if (self.selectionAvailable() == false) {
+ return;
+ }
+ const value = self.getValue();
+ const len: u32 = @intCast(value.len);
+ const start = @min(self._selection_start, len);
+ const end = @min(self._selection_end, len);
+
+ var new_start: u32 = undefined;
+ var new_end: u32 = undefined;
+ var new_direction: Selection.SelectionDirection = .none;
+
+ if (extend) {
+ const backward = self._selection_direction == .backward;
+ const anchor = if (backward) end else start;
+ const focus = caretTarget(value, if (backward) start else end, move);
+ if (focus < anchor) {
+ new_start = focus;
+ new_end = anchor;
+ new_direction = .backward;
+ } else {
+ new_start = anchor;
+ new_end = focus;
+ new_direction = if (focus > anchor) .forward else .none;
+ }
+ } else if (start != end and (move == .backward or move == .forward)) {
+ new_start = if (move == .backward) start else end;
+ new_end = new_start;
+ } else {
+ new_start = caretTarget(value, if (move == .backward) start else end, move);
+ new_end = new_start;
+ }
+
+ if (new_start == self._selection_start and new_end == self._selection_end and new_direction == self._selection_direction) {
+ return;
+ }
+ self._selection_start = new_start;
+ self._selection_end = new_end;
+ self._selection_direction = new_direction;
+ try dispatchSelectionChangeEvent(self, frame);
+ }
+
+ // Byte offset the caret lands on when moved from `pos`. Steps over
+ // whole UTF-8 sequences; line moves stop at the enclosing '\n' (an
+ // <input>'s sanitized value has none, so they reach the value's ends).
+ fn caretTarget(value: []const u8, pos: u32, move: CaretMove) u32 {
+ switch (move) {
+ .backward => {
+ if (pos == 0) return 0;
+ var p = pos - 1;
+ while (p > 0 and (value[p] & 0xC0) == 0x80) {
+ p -= 1;
+ }
+ return p;
+ },
+ .forward => {
+ if (pos >= value.len) return @intCast(value.len);
+ const next = pos + (std.unicode.utf8ByteSequenceLength(value[pos]) catch 1);
+ return @intCast(@min(next, value.len));
+ },
+ .line_start => {
+ const nl = std.mem.lastIndexOfScalar(u8, value[0..pos], '\n') orelse return 0;
+ return @intCast(nl + 1);
+ },
+ .line_end => {
+ const nl = std.mem.indexOfScalarPos(u8, value, pos, '\n') orelse return @intCast(value.len);
+ return @intCast(nl);
+ },
+ }
+ }
+
pub fn getSelectionDirection(self: *const T) []const u8 {
return @tagName(self._selection_direction);
}
diff --git a/src/server/cdp/domains/input.zig b/src/server/cdp/domains/input.zig
index 2c94cf844..8b1082ab6 100644
--- a/src/server/cdp/domains/input.zig
+++ b/src/server/cdp/domains/input.zig
@@ -169,6 +169,7 @@ test "cdp.input: insertText is a user edit for tooLong" {
\\const inp = document.getElementById('inp');
\\inp.maxLength = 3;
\\inp.value = 'abcdef';
+ \\inp.setSelectionRange(6, 6); // insertion happens at the caret; the value setter leaves it at 0
\\inp.focus();
, null);
try testing.expect((try ls.local.compileAndRun("inp.validity.tooLong === false", null)).isTrue());
@@ -522,3 +523,112 @@ test "cdp.input: editing keys honor the selection of a default-valued textarea"
});
try testing.expect((try ls.local.compileAndRun("ta.value === 'abf'", null)).isTrue());
}
+
+test "cdp.input: dispatchKeyEvent caret movement keys move the text entry cursor" {
+ var ctx = try testing.context();
+ defer ctx.deinit();
+
+ const bc = try ctx.loadBrowserContext(.{});
+ const page = try bc.session.createPage();
+ const frame = page.frame().?;
+
+ const url = "http://localhost:9582/src/browser/tests/mcp_actions.html";
+ try frame.navigate(url, .{ .reason = .address_bar, .kind = .{ .push = null } });
+ try testing.waitForPage(bc);
+
+ var ls: lp.js.Local.Scope = undefined;
+ frame.js.localScope(&ls);
+ defer ls.deinit();
+
+ var try_catch: lp.js.TryCatch = undefined;
+ try_catch.init(&ls.local);
+ defer try_catch.deinit();
+
+ _ = try ls.local.compileAndRun(
+ \\document.body.innerHTML = '<input id="t" type="text"><textarea id="ta"></textarea>';
+ \\const t = document.getElementById('t');
+ \\const ta = document.getElementById('ta');
+ \\const sel = (e) => [e.selectionStart, e.selectionEnd, e.selectionDirection].join(',');
+ \\t.focus(); t.value = 'abcdef'; t.setSelectionRange(6, 6);
+ , null);
+
+ const Step = struct { key: []const u8, modifiers: u4 = 0, expect: []const u8 };
+ const shift = 8;
+
+ // <input>: plain moves collapse, Shift extends from the anchor, a plain
+ // arrow on a selection collapses to its edge, ArrowUp/ArrowDown reach the
+ // ends of a single-line value.
+ const input_steps = [_]Step{
+ .{ .key = "ArrowLeft", .expect = "5,5,none" },
+ .{ .key = "ArrowRight", .expect = "6,6,none" },
+ .{ .key = "Home", .expect = "0,0,none" },
+ .{ .key = "End", .expect = "6,6,none" },
+ .{ .key = "ArrowUp", .expect = "0,0,none" },
+ .{ .key = "ArrowDown", .expect = "6,6,none" },
+ .{ .key = "ArrowRight", .expect = "6,6,none" },
+ .{ .key = "ArrowLeft", .modifiers = shift, .expect = "5,6,backward" },
+ .{ .key = "Home", .modifiers = shift, .expect = "0,6,backward" },
+ .{ .key = "ArrowLeft", .expect = "0,0,none" },
+ .{ .key = "ArrowLeft", .expect = "0,0,none" },
+ .{ .key = "End", .modifiers = shift, .expect = "0,6,forward" },
+ .{ .key = "ArrowLeft", .modifiers = shift, .expect = "0,5,forward" },
+ .{ .key = "ArrowRight", .expect = "5,5,none" },
+ };
+ var id: u32 = 1;
+ for (input_steps) |step| {
+ try ctx.processMessage(.{
+ .id = id,
+ .method = "Input.dispatchKeyEvent",
+ .params = .{ .type = "keyDown", .key = step.key, .code = step.key, .modifiers = step.modifiers },
+ });
+ id += 1;
+ const got = try (try ls.local.compileAndRun("sel(t)", null)).toStringSlice();
+ try testing.expectEqualSlices(u8, step.expect, got);
+ }
+
+ // Type-then-correct: move back two characters and insert in the middle.
+ _ = try ls.local.compileAndRun("t.setSelectionRange(6, 6)", null);
+ for (0..2) |_| {
+ try ctx.processMessage(.{
+ .id = id,
+ .method = "Input.dispatchKeyEvent",
+ .params = .{ .type = "keyDown", .key = "ArrowLeft", .code = "ArrowLeft" },
+ });
+ id += 1;
+ }
+ try ctx.processMessage(.{ .id = id, .method = "Input.insertText", .params = .{ .text = "X" } });
+ id += 1;
+ try testing.expect((try ls.local.compileAndRun("t.value === 'abcdXef' && sel(t) === '5,5,none'", null)).isTrue());
+
+ // Moves step over whole UTF-8 sequences, never landing inside one.
+ _ = try ls.local.compileAndRun("t.value = 'aé'; t.setSelectionRange(t.value.length, t.value.length)", null);
+ try ctx.processMessage(.{
+ .id = id,
+ .method = "Input.dispatchKeyEvent",
+ .params = .{ .type = "keyDown", .key = "ArrowLeft", .code = "ArrowLeft" },
+ });
+ id += 1;
+ try ctx.processMessage(.{ .id = id, .method = "Input.insertText", .params = .{ .text = "X" } });
+ id += 1;
+ try testing.expect((try ls.local.compileAndRun("t.value === 'aXé'", null)).isTrue());
+
+ // <textarea>: Home/End stop at the enclosing line break, ArrowLeft crosses it.
+ _ = try ls.local.compileAndRun("ta.focus(); ta.value = 'ab\\ncd'; ta.setSelectionRange(5, 5)", null);
+ const textarea_steps = [_]Step{
+ .{ .key = "Home", .expect = "3,3,none" },
+ .{ .key = "End", .expect = "5,5,none" },
+ .{ .key = "Home", .modifiers = shift, .expect = "3,5,backward" },
+ .{ .key = "ArrowLeft", .expect = "3,3,none" },
+ .{ .key = "ArrowLeft", .expect = "2,2,none" },
+ };
+ for (textarea_steps) |step| {
+ try ctx.processMessage(.{
+ .id = id,
+ .method = "Input.dispatchKeyEvent",
+ .params = .{ .type = "keyDown", .key = step.key, .code = step.key, .modifiers = step.modifiers },
+ });
+ id += 1;
+ const got = try (try ls.local.compileAndRun("sel(ta)", null)).toStringSlice();
+ try testing.expectEqualSlices(u8, step.expect, got);
+ }
+}