Skip to content

Lightpanda: the headless browser designed for AI and automation

webapi: replaceWith compliance

Karl Seguin5442e956941b
diff --git a/src/browser/tests/cdata/character_data.html b/src/browser/tests/cdata/character_data.html
index 85513b00f..09975a0a8 100644
--- a/src/browser/tests/cdata/character_data.html
+++ b/src/browser/tests/cdata/character_data.html
@@ -728,3 +728,13 @@
testing.expectEqual(null, comment.previousElementSibling);
}
</script>
+
+<script id="replaceWithAncestor">
+ {
+ const outer = document.createElement('div');
+ const text = document.createTextNode('t');
+ outer.appendChild(text);
+ testing.expectError('HierarchyRequestError', () => text.replaceWith(outer));
+ testing.expectEqual(outer, text.parentNode);
+ }
+</script>
diff --git a/src/browser/tests/element/replace_with.html b/src/browser/tests/element/replace_with.html
index a5524aef0..758d4b70c 100644
--- a/src/browser/tests/element/replace_with.html
+++ b/src/browser/tests/element/replace_with.html
@@ -450,3 +450,60 @@
// Layout walks the document's elements, asserting each is its own.
testing.expectEqual(true, document.documentElement.scrollWidth > 0);
</script>
+
+<!-- Test 18: Replacing with an ancestor throws instead of creating a cycle -->
+<script id=test18-ancestor>
+ const outer18 = document.createElement('div');
+ const inner18 = document.createElement('div');
+ const leaf18 = document.createElement('span');
+ outer18.appendChild(inner18);
+ inner18.appendChild(leaf18);
+
+ testing.expectError('HierarchyRequestError', () => leaf18.replaceWith(outer18));
+ testing.expectError('HierarchyRequestError', () => leaf18.replaceWith(inner18));
+ testing.expectEqual(inner18, leaf18.parentNode);
+ testing.expectEqual(outer18, inner18.parentNode);
+ testing.expectEqual(null, outer18.parentNode);
+</script>
+
+<!-- Test 19: A Document or DocumentType can't replace an element -->
+<script id=test19-invalid-node-types>
+ const parent19 = document.createElement('div');
+ const old19 = document.createElement('div');
+ parent19.appendChild(old19);
+
+ const other19 = document.implementation.createHTMLDocument('other');
+ testing.expectError('HierarchyRequestError', () => old19.replaceWith(other19));
+ testing.expectError('HierarchyRequestError', () => old19.replaceWith(other19.doctype));
+ testing.expectEqual(parent19, old19.parentNode);
+ testing.expectEqual(1, parent19.childNodes.length);
+</script>
+
+<!-- Test 20: Several nodes are one insertion: a single childList record -->
+<script id=test20-single-record>
+ const parent20 = document.createElement('div');
+ const old20 = document.createElement('div');
+ const a20 = document.createElement('b');
+ const b20 = document.createElement('i');
+ parent20.appendChild(old20);
+
+ const observer20 = new MutationObserver(() => {});
+ observer20.observe(parent20, { childList: true });
+ old20.replaceWith(a20, 'text', b20);
+ const records20 = observer20.takeRecords();
+
+ testing.expectEqual(1, records20.length);
+ testing.expectEqual(3, records20[0].addedNodes.length);
+ testing.expectEqual(old20, records20[0].removedNodes[0]);
+ testing.expectEqual('B,#text,I', [...parent20.childNodes].map(n => n.nodeName).join(','));
+</script>
+
+<!-- Test 21: No arguments removes the element -->
+<script id=test21-empty>
+ const parent21 = document.createElement('div');
+ const old21 = document.createElement('div');
+ parent21.appendChild(old21);
+ old21.replaceWith();
+ testing.expectEqual(null, old21.parentNode);
+ testing.expectEqual(0, parent21.childNodes.length);
+</script>
diff --git a/src/browser/webapi/CData.zig b/src/browser/webapi/CData.zig
index 89542fb65..c9adde5f0 100644
--- a/src/browser/webapi/CData.zig
+++ b/src/browser/webapi/CData.zig
@@ -461,22 +461,7 @@ pub fn after(self: *CData, nodes: []const Node.NodeOrText, frame: *Frame) !void
}
pub fn replaceWith(self: *CData, nodes: []const Node.NodeOrText, frame: *Frame) !void {
- const ref_node = self.asNode();
- const parent = ref_node.parentNode() orelse return;
-
- var rm_ref_node = true;
- for (nodes) |node_or_text| {
- const child = try node_or_text.toNode(ref_node.getDocument(frame));
- if (child == ref_node) {
- rm_ref_node = false;
- continue;
- }
- _ = try parent.insertBefore(child, ref_node, frame);
- }
-
- if (rm_ref_node) {
- _ = try parent.removeChild(ref_node, frame);
- }
+ return self.asNode().replaceWithNodes(nodes, frame);
}
pub fn nextElementSibling(self: *CData) ?*Node.Element {
diff --git a/src/browser/webapi/Element.zig b/src/browser/webapi/Element.zig
index 42d4bbd8c..28c9a37ce 100644
--- a/src/browser/webapi/Element.zig
+++ b/src/browser/webapi/Element.zig
@@ -1189,57 +1189,7 @@ pub fn replaceChildren(self: *Element, nodes: []const Node.NodeOrText, frame: *F
}
pub fn replaceWith(self: *Element, nodes: []const Node.NodeOrText, frame: *Frame) !void {
- const ref_node = self.asNode();
- const parent = ref_node._parent orelse return;
- frame.domChanged();
-
- // Detect if the ref_node must be removed (by default) or kept.
- // We kept it when ref_node is present into the nodes list.
- var rm_ref_node = true;
-
- for (nodes) |node_or_text| {
- const child = try node_or_text.toNode(self.getDocument(frame));
-
- // If a child is the ref node. We keep it at its own current position.
- if (child == ref_node) {
- rm_ref_node = false;
- continue;
- }
-
- // A DocumentFragment contributes its children, not itself
- if (child.is(Node.DocumentFragment)) |_| {
- try frame.insertAllChildrenBefore(child, parent, ref_node);
- continue;
- }
-
- // A node from another document is adopted, as insertBefore does
- const child_owner = child.ownerDocument(frame);
- const parent_owner = parent.ownerDocument(frame) orelse parent.as(Node.Document);
- const adopting = child_owner != null and child_owner.? != parent_owner;
-
- var previous_root: ?*Node = null;
- if (child._parent) |current_parent| {
- previous_root = child.getRootNode(.{});
- frame.removeNode(current_parent, child, .{ .reconnect_to = if (adopting) null else parent });
- }
-
- if (adopting) {
- try frame.adoptNodeTree(child, child_owner.?, parent_owner);
- }
-
- try frame.insertNodeRelative(
- parent,
- child,
- .{ .before = ref_node },
- .{ .previous_root = previous_root, .adopting_to_new_document = adopting },
- );
- }
-
- // Re-check parent after insertNodeRelative since callbacks (e.g. connectedCallback)
- // could have already removed ref_node from parent.
- if (rm_ref_node and ref_node._parent == parent) {
- frame.removeNode(parent, ref_node, .{ .reconnect_to = null });
- }
+ return self.asNode().replaceWithNodes(nodes, frame);
}
pub fn remove(self: *Element, frame: *Frame) void {
diff --git a/src/browser/webapi/Node.zig b/src/browser/webapi/Node.zig
index 6edb241f5..4d0aa3b99 100644
--- a/src/browser/webapi/Node.zig
+++ b/src/browser/webapi/Node.zig
@@ -1512,6 +1512,35 @@ pub fn prependNodes(self: *Node, nodes: []const NodeOrText, frame: *Frame) !void
_ = try self.insertBefore(fragment_node, self.firstChild(), frame);
}
+/// Element and CharacterData replaceWith.
+pub fn replaceWithNodes(self: *Node, nodes: []const NodeOrText, frame: *Frame) !void {
+ const parent = self._parent orelse return;
+ const viable_next = NodeOrText.viableNextSibling(self, nodes);
+
+ if (nodes.len == 1) {
+ const node = try nodes[0].toNode(self.getDocument(frame));
+ _ = try parent.replaceChild(node, self, frame);
+ return;
+ }
+
+ const fragment = try DocumentFragment.init(self.getDocument(frame), frame);
+ const fragment_node = fragment.asNode();
+ defer if (fragment_node.firstChild() == null) {
+ frame._factory.destroy(fragment);
+ };
+ for (nodes) |node_or_text| {
+ const child = try node_or_text.toNode(self.getDocument(frame));
+ _ = try fragment_node.appendChild(child, frame);
+ }
+
+ // self may itself be one of the nodes, now moved into the fragment.
+ if (self._parent == parent) {
+ _ = try parent.replaceChild(fragment_node, self, frame);
+ } else {
+ _ = try parent.insertBefore(fragment_node, viable_next, frame);
+ }
+}
+
/// Shared implementation of replaceChildren for Element, Document, and DocumentFragment.
pub fn replaceChildren(self: *Node, nodes: []const NodeOrText, frame: *Frame) !void {
if (nodes.len > 1) {