Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: implement the spec algorithm for Range.deleteContents

Francis Bouvier5bc2d8ede256
diff --git a/src/browser/webapi/Range.zig b/src/browser/webapi/Range.zig
index d7237fdae..deefa9b47 100644
--- a/src/browser/webapi/Range.zig
+++ b/src/browser/webapi/Range.zig
@@ -395,76 +395,87 @@ pub fn deleteContents(self: *Range, frame: *Frame) !void {
}
frame.domChanged();
- // Simple case: same container
- if (self._proto._start_container == self._proto._end_container) {
- if (self._proto._start_container.is(Node.CData)) |cdata| {
- // Delete part of text node
- const old_value = cdata.getData();
- const text_data = old_value.str();
- cdata._data = try String.concat(
- frame.arena,
- &.{
- text_data[0..byteOffset(text_data, self._proto._start_offset)],
- text_data[byteOffset(text_data, self._proto._end_offset)..],
- },
- );
- Frame.observers.notifyCharacterDataChange(frame, self._proto._start_container, old_value);
- } else {
- // Delete child nodes in range.
- // Capture count before the loop: removeChild triggers live range
- // updates that decrement _end_offset on each removal.
- const count = self._proto._end_offset - self._proto._start_offset;
- var i: u32 = 0;
- while (i < count) : (i += 1) {
- if (self._proto._start_container.getChildAt(self._proto._start_offset)) |child| {
- _ = try self._proto._start_container.removeChild(child, frame);
- }
- }
+ const start_node = self._proto._start_container;
+ const start_offset = self._proto._start_offset;
+ const end_node = self._proto._end_container;
+ const end_offset = self._proto._end_offset;
+
+ // Same CharacterData container: replace the data in place.
+ if (start_node == end_node) {
+ if (start_node.is(Node.CData)) |cdata| {
+ try cdata.replaceData(start_offset, end_offset - start_offset, "", frame);
+ try self.setStart(start_node, start_offset);
+ try self.setEnd(start_node, start_offset);
+ return;
}
- self.collapse(true);
- return;
}
- // Complex case: different containers
- // Handle start container - if it's a text node, truncate it
- if (self._proto._start_container.is(Node.CData)) |cdata| {
- const text_data = cdata._data.str();
- const byte_start = byteOffset(text_data, self._proto._start_offset);
- if (byte_start < text_data.len) {
- // Keep only the part before start_offset
- const new_text = text_data[0..byte_start];
- try self._proto._start_container.setData(new_text, frame);
+ // Contained nodes whose parent isn't also contained, in tree order.
+ var to_remove: std.ArrayList(*Node) = .empty;
+ try self.collectContained(self._proto.getCommonAncestorContainer(), &to_remove, frame.call_arena);
+
+ // Where the collapsed range ends up: the start point if the start node
+ // is an inclusive ancestor of the end node; otherwise just after the
+ // highest partially-contained ancestor of the start node.
+ var new_node = start_node;
+ var new_offset = start_offset;
+ if (start_node != end_node and !start_node.contains(end_node)) {
+ var reference = start_node;
+ while (reference.parentNode()) |parent| {
+ if (parent == end_node or parent.contains(end_node)) break;
+ reference = parent;
}
+ new_node = reference.parentNode().?;
+ new_offset = (new_node.getChildIndex(reference) orelse 0) + 1;
}
- // Handle end container - if it's a text node, truncate it
- if (self._proto._end_container.is(Node.CData)) |cdata| {
- const text_data = cdata._data.str();
- const byte_end = byteOffset(text_data, self._proto._end_offset);
- if (byte_end < text_data.len) {
- // Keep only the part from end_offset onwards
- const new_text = text_data[byte_end..];
- try self._proto._end_container.setData(new_text, frame);
- } else if (byte_end == text_data.len) {
- // If we're at the end, set to empty (will be removed if needed)
- try self._proto._end_container.setData("", frame);
+ if (start_node.is(Node.CData)) |cdata| {
+ const length: u32 = @intCast(cdata.getLength());
+ try cdata.replaceData(start_offset, length - start_offset, "", frame);
+ }
+
+ for (to_remove.items) |node| {
+ if (node.parentNode()) |parent| {
+ _ = try parent.removeChild(node, frame);
}
}
- // Remove nodes between start and end containers
- // For now, handle the common case where they're siblings
- if (self._proto._start_container.parentNode() == self._proto._end_container.parentNode()) {
- var current = self._proto._start_container.nextSibling();
- while (current != null and current != self._proto._end_container) {
- const next = current.?.nextSibling();
- if (current.?.parentNode()) |parent| {
- _ = try parent.removeChild(current.?, frame);
- }
- current = next;
+ if (end_node.is(Node.CData)) |cdata| {
+ try cdata.replaceData(0, end_offset, "", frame);
+ }
+
+ try self.setStart(new_node, new_offset);
+ try self.setEnd(new_node, new_offset);
+}
+
+// A node is contained in the range when its whole extent lies between the
+// range's boundary points. Appends the top-most contained nodes (those whose
+// parent isn't contained) under `node`, without descending into them.
+fn collectContained(self: *const Range, node: *Node, list: *std.ArrayList(*Node), arena: std.mem.Allocator) !void {
+ var child = node.firstChild();
+ while (child) |c| : (child = c.nextSibling()) {
+ if (self.nodeContained(c)) {
+ try list.append(arena, c);
+ } else {
+ try self.collectContained(c, list, arena);
}
}
+}
- self.collapse(true);
+fn nodeContained(self: *const Range, node: *Node) bool {
+ const after_start = AbstractRange.compareBoundaryPoints(
+ node,
+ 0,
+ self._proto._start_container,
+ self._proto._start_offset,
+ ) == .after;
+ if (!after_start) return false;
+ return AbstractRange.compareBoundaryPoints(
+ node,
+ node.getLength(),
+ self._proto._end_container,
+ self._proto._end_offset,
+ ) == .before;
}
pub fn cloneContents(self: *const Range, frame: *Frame) !*DocumentFragment {