Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: spec mutation records for fragment insertion and replaceChild

Francis Bouvierc6b592e782e5
diff --git a/src/browser/Frame.zig b/src/browser/Frame.zig
index 31d25fa9c..0dc1b3805 100644
--- a/src/browser/Frame.zig
+++ b/src/browser/Frame.zig
@@ -2487,31 +2487,50 @@ pub fn appendNode(self: *Frame, parent: *Node, child: *Node, opts: InsertNodeOpt
}
pub fn appendAllChildren(self: *Frame, parent: *Node, target: *Node) !void {
- self.domChanged();
- const dest_connected = target.isConnected();
-
- var it = parent.childrenIterator();
- while (it.next()) |child| {
- const child_was_connected = child.isConnected();
- self.removeNode(parent, child, .{ .will_be_reconnected = dest_connected });
- try self.appendNode(target, child, .{ .child_already_connected = child_was_connected });
- }
+ return self.moveAllChildren(parent, target, null, .records);
}
pub fn insertAllChildrenBefore(self: *Frame, fragment: *Node, parent: *Node, ref_node: *Node) !void {
+ return self.moveAllChildren(fragment, parent, ref_node, .records);
+}
+
+pub const MoveChildrenNotify = enum { records, silent };
+
+// Moves every child of `source` into `parent` (before `ref_node`, or
+// appended). Per the DOM insert algorithm for fragments, observers get one
+// removal record on the source and one addition record on the parent, not
+// one record per child. `.silent` suppresses even those (replaceChild queues
+// its own combined record).
+pub fn moveAllChildren(self: *Frame, source: *Node, parent: *Node, ref_node: ?*Node, notify_mode: MoveChildrenNotify) !void {
self.domChanged();
const dest_connected = parent.isConnected();
+ const notify = notify_mode == .records and observers.hasMutationObservers(self);
- var it = fragment.childrenIterator();
+ var moved: std.ArrayList(*Node) = .empty;
+ const previous_sibling = if (ref_node) |ref| ref.previousSibling() else parent.lastChild();
+
+ var it = source.childrenIterator();
while (it.next()) |child| {
+ if (notify) {
+ try moved.append(self.call_arena, child);
+ }
const child_was_connected = child.isConnected();
- self.removeNode(fragment, child, .{ .will_be_reconnected = dest_connected });
- try self.insertNodeRelative(
- parent,
- child,
- .{ .before = ref_node },
- .{ .child_already_connected = child_was_connected },
- );
+ self.removeNode(source, child, .{ .will_be_reconnected = dest_connected, .notify_observers = false });
+ if (ref_node) |ref| {
+ try self.insertNodeRelative(
+ parent,
+ child,
+ .{ .before = ref },
+ .{ .child_already_connected = child_was_connected, .notify_observers = false },
+ );
+ } else {
+ try self.appendNode(parent, child, .{ .child_already_connected = child_was_connected, .notify_observers = false });
+ }
+ }
+
+ if (notify and moved.items.len > 0) {
+ observers.notifyChildListChange(self, source, &.{}, moved.items, null, null);
+ observers.notifyChildListChange(self, parent, moved.items, &.{}, previous_sibling, ref_node);
}
}
diff --git a/src/browser/tests/mutation_observer/childlist.html b/src/browser/tests/mutation_observer/childlist.html
index ea93718f3..30757c918 100644
--- a/src/browser/tests/mutation_observer/childlist.html
+++ b/src/browser/tests/mutation_observer/childlist.html
@@ -183,28 +183,18 @@
replaceParent.replaceChild(replaceNew, replaceOld);
await state.done((mutations) => {
- // replaceChild generates two separate mutation records in modern spec:
- // 1. First record for insertBefore (new node added)
- // 2. Second record for removeChild (old node removed)
- testing.expectEqual(2, mutations.length);
+ // Per the DOM "replace" algorithm, replaceChild queues one combined
+ // mutation record with both the added and the removed node.
+ testing.expectEqual(1, mutations.length);
- // First mutation: insertion of new node
testing.expectEqual('childList', mutations[0].type);
testing.expectEqual(replaceParent, mutations[0].target);
testing.expectEqual(1, mutations[0].addedNodes.length);
testing.expectEqual(replaceNew, mutations[0].addedNodes[0]);
- testing.expectEqual(0, mutations[0].removedNodes.length);
+ testing.expectEqual(1, mutations[0].removedNodes.length);
+ testing.expectEqual(replaceOld, mutations[0].removedNodes[0]);
testing.expectEqual(null, mutations[0].previousSibling);
- testing.expectEqual(replaceOld, mutations[0].nextSibling);
-
- // Second mutation: removal of old node
- testing.expectEqual('childList', mutations[1].type);
- testing.expectEqual(replaceParent, mutations[1].target);
- testing.expectEqual(0, mutations[1].addedNodes.length);
- testing.expectEqual(1, mutations[1].removedNodes.length);
- testing.expectEqual(replaceOld, mutations[1].removedNodes[0]);
- testing.expectEqual(replaceNew, mutations[1].previousSibling);
- testing.expectEqual(null, mutations[1].nextSibling);
+ testing.expectEqual(null, mutations[0].nextSibling);
});
</script>
diff --git a/src/browser/webapi/Node.zig b/src/browser/webapi/Node.zig
index 1be03fe94..999c19abe 100644
--- a/src/browser/webapi/Node.zig
+++ b/src/browser/webapi/Node.zig
@@ -824,11 +824,73 @@ fn insertBeforeInner(self: *Node, new_node: *Node, ref_node_: ?*Node, frame: *Fr
pub fn replaceChild(self: *Node, new_child: *Node, old_child: *Node, frame: *Frame) !*Node {
try ensurePreInsertValidity(self, new_child, old_child, .replace);
- _ = try self.insertBeforeInner(new_child, old_child, frame);
+ frame.domChanged();
+ const notify = Frame.observers.hasMutationObservers(frame);
+
+ if (new_child == old_child) {
+ // Replacing a node with itself doesn't change the tree; observers
+ // still get a removal record followed by an addition record.
+ if (notify) {
+ const prev = old_child.previousSibling();
+ const next = old_child.nextSibling();
+ const nodes = [_]*Node{old_child};
+ Frame.observers.notifyChildListChange(frame, self, &.{}, &nodes, prev, next);
+ Frame.observers.notifyChildListChange(frame, self, &nodes, &.{}, prev, next);
+ }
+ return old_child;
+ }
+
+ // Removing new_child from its current position (internal replacement)
+ // notifies normally; the replacement itself queues one combined record
+ // with both the added and the removed node.
+ const child_already_connected = new_child.isConnected();
+ const child_owner = new_child.ownerDocument(frame);
+ const parent_owner = self.ownerDocument(frame) orelse self.as(Document);
+ const adopting = child_owner != null and child_owner.? != parent_owner;
+ const will_be_reconnected = self.isConnected() and !adopting;
+
+ if (new_child.is(DocumentFragment) == null) {
+ if (new_child._parent) |previous_parent| {
+ frame.removeNode(previous_parent, new_child, .{ .will_be_reconnected = will_be_reconnected });
+ }
+ if (adopting) {
+ try frame.adoptNodeTree(new_child, child_owner.?, parent_owner);
+ }
+ }
- // Special case: if we replace a node by itself, insertBefore was a noop.
- if (new_child != old_child) {
- frame.removeNode(self, old_child, .{ .will_be_reconnected = false });
+ const prev = old_child.previousSibling();
+ const next = old_child.nextSibling();
+
+ var added: std.ArrayList(*Node) = .empty;
+ if (new_child.is(DocumentFragment)) |_| {
+ if (notify) {
+ var it = new_child.childrenIterator();
+ while (it.next()) |fragment_child| {
+ try added.append(frame.call_arena, fragment_child);
+ }
+ }
+ try frame.moveAllChildren(new_child, self, old_child, .silent);
+ } else {
+ if (notify) {
+ try added.append(frame.call_arena, new_child);
+ }
+ try frame.insertNodeRelative(
+ self,
+ new_child,
+ .{ .before = old_child },
+ .{
+ .child_already_connected = child_already_connected,
+ .adopting_to_new_document = adopting,
+ .notify_observers = false,
+ },
+ );
+ }
+
+ frame.removeNode(self, old_child, .{ .will_be_reconnected = false, .notify_observers = false });
+
+ if (notify) {
+ const removed = [_]*Node{old_child};
+ Frame.observers.notifyChildListChange(frame, self, added.items, &removed, prev, next);
}
return old_child;
diff --git a/src/browser/webapi/Range.zig b/src/browser/webapi/Range.zig
index 9c0b9263f..35f6eec10 100644
--- a/src/browser/webapi/Range.zig
+++ b/src/browser/webapi/Range.zig
@@ -347,19 +347,16 @@ pub fn insertNode(self: *Range, node: *Node, frame: *Frame) !void {
} else {
const text_data = container.getData().str();
const byte_off = byteOffset(text_data, offset);
- if (byte_off >= text_data.len) {
- _ = try parent.insertBefore(node, container.nextSibling(), frame);
+ const text = if (byte_off < text_data.len) container.is(Node.CData.Text) else null;
+ if (text) |t| {
+ // Split the text node in place and insert before the second
+ // half. splitText keeps live ranges updated and produces the
+ // records browsers do (one for the split-off node, one for
+ // the inserted node).
+ const second = try t.splitText(offset, frame);
+ _ = try parent.insertBefore(node, second._proto.asNode(), frame);
} else {
- // Split the text node into before and after parts
- const before_text = text_data[0..byte_off];
- const after_text = text_data[byte_off..];
-
- const before = try Frame.node_factory.createTextNode(frame, before_text);
- const after = try Frame.node_factory.createTextNode(frame, after_text);
-
- _ = try parent.replaceChild(before, container, frame);
- _ = try parent.insertBefore(node, before.nextSibling(), frame);
- _ = try parent.insertBefore(after, node.nextSibling(), frame);
+ _ = try parent.insertBefore(node, container.nextSibling(), frame);
}
}
} else {