@tkeron/html-parser 0.1.4 → 0.1.7

package/tests/dom-manipulation.test.ts

@@ -686,3 +686,641 @@ describe("DOM Manipulation - insertAfter", () => {
     });
   });
 });
+
+describe("DOM Manipulation - prepend", () => {
+  describe("Basic prepend functionality", () => {
+    it("should prepend a single node to an element with children", () => {
+      const doc = parseHTML("<div><span>Second</span><span>Third</span></div>");
+      const div = doc.querySelector("div");
+      const secondSpan = div.childNodes[0];
+
+      const newSpan = doc.createElement("span");
+      newSpan.textContent = "First";
+
+      div.prepend(newSpan);
+
+      expect(div.childNodes.length).toBe(3);
+      expect(div.childNodes[0]).toBe(newSpan);
+      expect(div.childNodes[1]).toBe(secondSpan);
+      expect(div.firstChild).toBe(newSpan);
+    });
+
+    it("should prepend a node to an empty element", () => {
+      const doc = parseHTML("<div></div>");
+      const div = doc.querySelector("div");
+
+      const span = doc.createElement("span");
+      span.textContent = "First";
+
+      div.prepend(span);
+
+      expect(div.childNodes.length).toBe(1);
+      expect(div.childNodes[0]).toBe(span);
+      expect(div.firstChild).toBe(span);
+      expect(div.lastChild).toBe(span);
+    });
+
+    it("should prepend multiple nodes", () => {
+      const doc = parseHTML("<div><span>Third</span></div>");
+      const div = doc.querySelector("div");
+
+      const first = doc.createElement("span");
+      first.textContent = "First";
+      const second = doc.createElement("span");
+      second.textContent = "Second";
+
+      div.prepend(first, second);
+
+      expect(div.childNodes.length).toBe(3);
+      expect(div.childNodes[0]).toBe(first);
+      expect(div.childNodes[1]).toBe(second);
+      expect(div.childNodes[2].textContent).toBe("Third");
+      expect(div.firstChild).toBe(first);
+    });
+
+    it("should prepend with string argument", () => {
+      const doc = parseHTML("<div><span>Element</span></div>");
+      const div = doc.querySelector("div");
+
+      div.prepend("Text before ");
+
+      expect(div.childNodes.length).toBe(2);
+      expect(div.childNodes[0].nodeType).toBe(NodeType.TEXT_NODE);
+      expect(div.childNodes[0].textContent).toBe("Text before ");
+      expect(div.firstChild.nodeValue).toBe("Text before ");
+    });
+
+    it("should prepend mixed nodes and strings", () => {
+      const doc = parseHTML("<div><span>Last</span></div>");
+      const div = doc.querySelector("div");
+
+      const span = doc.createElement("span");
+      span.textContent = "Second";
+
+      div.prepend("First ", span);
+
+      expect(div.childNodes.length).toBe(3);
+      expect(div.childNodes[0].nodeType).toBe(NodeType.TEXT_NODE);
+      expect(div.childNodes[0].textContent).toBe("First ");
+      expect(div.childNodes[1]).toBe(span);
+      expect(div.childNodes[2].textContent).toBe("Last");
+    });
+
+    it("should do nothing when called with no arguments", () => {
+      const doc = parseHTML("<div><span>Only</span></div>");
+      const div = doc.querySelector("div");
+      const originalLength = div.childNodes.length;
+
+      div.prepend();
+
+      expect(div.childNodes.length).toBe(originalLength);
+    });
+  });
+
+  describe("prepend with text nodes", () => {
+    it("should prepend text node before elements", () => {
+      const doc = parseHTML("<div><span>Element</span></div>");
+      const div = doc.querySelector("div");
+      const span = div.childNodes[0];
+
+      const textNode = doc.createTextNode("Text ");
+
+      div.prepend(textNode);
+
+      expect(div.childNodes.length).toBe(2);
+      expect(div.childNodes[0]).toBe(textNode);
+      expect(div.childNodes[1]).toBe(span);
+      expect(div.firstChild).toBe(textNode);
+    });
+  });
+
+  describe("prepend sibling relationships", () => {
+    it("should update nextSibling and previousSibling correctly", () => {
+      const doc = parseHTML("<div><span>B</span><span>C</span></div>");
+      const div = doc.querySelector("div");
+      const spanB = div.childNodes[0];
+
+      const spanA = doc.createElement("span");
+      spanA.textContent = "A";
+
+      div.prepend(spanA);
+
+      expect(spanA.nextSibling).toBe(spanB);
+      expect(spanA.previousSibling).toBeNull();
+      expect(spanB.previousSibling).toBe(spanA);
+      expect(div.firstChild).toBe(spanA);
+    });
+
+    it("should update element sibling relationships", () => {
+      const doc = parseHTML("<div><span>B</span></div>");
+      const div = doc.querySelector("div");
+      const spanB = div.childNodes[0];
+
+      const spanA = doc.createElement("span");
+      spanA.textContent = "A";
+
+      div.prepend(spanA);
+
+      expect(spanA.nextElementSibling).toBe(spanB);
+      expect(spanA.previousElementSibling).toBeNull();
+      expect(spanB.previousElementSibling).toBe(spanA);
+      expect(div.firstElementChild).toBe(spanA);
+    });
+  });
+
+  describe("prepend with parent relocation", () => {
+    it("should move node from another parent when prepending", () => {
+      const doc = parseHTML("<div id='a'><span>Child</span></div><div id='b'><span>Other</span></div>");
+      const divA = doc.querySelector("#a");
+      const divB = doc.querySelector("#b");
+      const child = divA.querySelector("span");
+
+      divB.prepend(child);
+
+      expect(divA.childNodes.length).toBe(0);
+      expect(divB.childNodes.length).toBe(2);
+      expect(divB.firstChild).toBe(child);
+      expect(child.parentNode).toBe(divB);
+    });
+
+    it("should remove from old parent before prepending", () => {
+      const doc = parseHTML("<div id='a'><span id='1'>1</span><span id='2'>2</span></div><div id='b'></div>");
+      const divA = doc.querySelector("#a");
+      const divB = doc.querySelector("#b");
+      const span1 = doc.querySelector("#1");
+
+      divB.prepend(span1);
+
+      expect(divA.childNodes.length).toBe(1);
+      expect(divA.childNodes[0].textContent).toBe("2");
+      expect(divB.childNodes.length).toBe(1);
+      expect(divB.firstChild).toBe(span1);
+    });
+  });
+
+  describe("prepend synchronization", () => {
+    it("should update innerHTML correctly", () => {
+      const doc = parseHTML("<div><span>B</span><span>C</span></div>");
+      const div = doc.querySelector("div");
+
+      const spanA = doc.createElement("span");
+      spanA.textContent = "A";
+
+      div.prepend(spanA);
+
+      expect(div.innerHTML).toBe("<span>A</span><span>B</span><span>C</span>");
+    });
+
+    it("should update innerHTML with multiple prepends", () => {
+      const doc = parseHTML("<div><span>C</span></div>");
+      const div = doc.querySelector("div");
+
+      const spanA = doc.createElement("span");
+      spanA.textContent = "A";
+      const spanB = doc.createElement("span");
+      spanB.textContent = "B";
+
+      div.prepend(spanA, spanB);
+
+      expect(div.innerHTML).toBe("<span>A</span><span>B</span><span>C</span>");
+    });
+
+    it("should update textContent correctly", () => {
+      const doc = parseHTML("<div><span>Second</span></div>");
+      const div = doc.querySelector("div");
+
+      div.prepend("First ");
+
+      expect(div.textContent).toBe("First Second");
+    });
+  });
+
+  describe("prepend on document", () => {
+    it("should prepend to document", () => {
+      const doc = parseHTML("<!-- Comment --><div>Content</div>");
+      const comment = doc.childNodes[0];
+      const div = doc.childNodes[1];
+
+      const newDiv = doc.createElement("div");
+      newDiv.textContent = "First";
+
+      doc.prepend(newDiv);
+
+      expect(doc.firstChild).toBe(newDiv);
+      expect(newDiv.nextSibling).toBe(comment);
+      expect(doc.childNodes.length).toBe(3);
+    });
+  });
+});
+
+describe("DOM Manipulation - append", () => {
+  describe("Basic append functionality", () => {
+    it("should append a single node to an element with children", () => {
+      const doc = parseHTML("<div><span>First</span><span>Second</span></div>");
+      const div = doc.querySelector("div");
+      const secondSpan = div.childNodes[1];
+
+      const newSpan = doc.createElement("span");
+      newSpan.textContent = "Third";
+
+      div.append(newSpan);
+
+      expect(div.childNodes.length).toBe(3);
+      expect(div.childNodes[2]).toBe(newSpan);
+      expect(div.lastChild).toBe(newSpan);
+      expect(secondSpan.nextSibling).toBe(newSpan);
+    });
+
+    it("should append a node to an empty element", () => {
+      const doc = parseHTML("<div></div>");
+      const div = doc.querySelector("div");
+
+      const span = doc.createElement("span");
+      span.textContent = "First";
+
+      div.append(span);
+
+      expect(div.childNodes.length).toBe(1);
+      expect(div.childNodes[0]).toBe(span);
+      expect(div.firstChild).toBe(span);
+      expect(div.lastChild).toBe(span);
+    });
+
+    it("should append multiple nodes", () => {
+      const doc = parseHTML("<div><span>First</span></div>");
+      const div = doc.querySelector("div");
+
+      const second = doc.createElement("span");
+      second.textContent = "Second";
+      const third = doc.createElement("span");
+      third.textContent = "Third";
+
+      div.append(second, third);
+
+      expect(div.childNodes.length).toBe(3);
+      expect(div.childNodes[1]).toBe(second);
+      expect(div.childNodes[2]).toBe(third);
+      expect(div.lastChild).toBe(third);
+    });
+
+    it("should append with string argument", () => {
+      const doc = parseHTML("<div><span>Element</span></div>");
+      const div = doc.querySelector("div");
+
+      div.append(" text after");
+
+      expect(div.childNodes.length).toBe(2);
+      expect(div.childNodes[1].nodeType).toBe(NodeType.TEXT_NODE);
+      expect(div.childNodes[1].textContent).toBe(" text after");
+      expect(div.lastChild.nodeValue).toBe(" text after");
+    });
+
+    it("should append mixed nodes and strings", () => {
+      const doc = parseHTML("<div><span>First</span></div>");
+      const div = doc.querySelector("div");
+
+      const span = doc.createElement("span");
+      span.textContent = "Second";
+
+      div.append(span, " and text");
+
+      expect(div.childNodes.length).toBe(3);
+      expect(div.childNodes[1]).toBe(span);
+      expect(div.childNodes[2].nodeType).toBe(NodeType.TEXT_NODE);
+      expect(div.childNodes[2].textContent).toBe(" and text");
+    });
+
+    it("should do nothing when called with no arguments", () => {
+      const doc = parseHTML("<div><span>Only</span></div>");
+      const div = doc.querySelector("div");
+      const originalLength = div.childNodes.length;
+
+      div.append();
+
+      expect(div.childNodes.length).toBe(originalLength);
+    });
+  });
+
+  describe("append with text nodes", () => {
+    it("should append text node after elements", () => {
+      const doc = parseHTML("<div><span>Element</span></div>");
+      const div = doc.querySelector("div");
+      const span = div.childNodes[0];
+
+      const textNode = doc.createTextNode(" Text");
+
+      div.append(textNode);
+
+      expect(div.childNodes.length).toBe(2);
+      expect(div.childNodes[1]).toBe(textNode);
+      expect(div.lastChild).toBe(textNode);
+    });
+  });
+
+  describe("append sibling relationships", () => {
+    it("should update nextSibling and previousSibling correctly", () => {
+      const doc = parseHTML("<div><span>A</span><span>B</span></div>");
+      const div = doc.querySelector("div");
+      const spanB = div.childNodes[1];
+
+      const spanC = doc.createElement("span");
+      spanC.textContent = "C";
+
+      div.append(spanC);
+
+      expect(spanB.nextSibling).toBe(spanC);
+      expect(spanC.previousSibling).toBe(spanB);
+      expect(spanC.nextSibling).toBeNull();
+      expect(div.lastChild).toBe(spanC);
+    });
+
+    it("should update element sibling relationships", () => {
+      const doc = parseHTML("<div><span>A</span></div>");
+      const div = doc.querySelector("div");
+      const spanA = div.childNodes[0];
+
+      const spanB = doc.createElement("span");
+      spanB.textContent = "B";
+
+      div.append(spanB);
+
+      expect(spanA.nextElementSibling).toBe(spanB);
+      expect(spanB.previousElementSibling).toBe(spanA);
+      expect(spanB.nextElementSibling).toBeNull();
+      expect(div.lastElementChild).toBe(spanB);
+    });
+  });
+
+  describe("append with parent relocation", () => {
+    it("should move node from another parent when appending", () => {
+      const doc = parseHTML("<div id='a'><span>Child</span></div><div id='b'><span>Other</span></div>");
+      const divA = doc.querySelector("#a");
+      const divB = doc.querySelector("#b");
+      const child = divA.querySelector("span");
+
+      divB.append(child);
+
+      expect(divA.childNodes.length).toBe(0);
+      expect(divB.childNodes.length).toBe(2);
+      expect(divB.lastChild).toBe(child);
+      expect(child.parentNode).toBe(divB);
+    });
+
+    it("should remove from old parent before appending", () => {
+      const doc = parseHTML("<div id='a'><span id='1'>1</span><span id='2'>2</span></div><div id='b'></div>");
+      const divA = doc.querySelector("#a");
+      const divB = doc.querySelector("#b");
+      const span2 = doc.querySelector("#2");
+
+      divB.append(span2);
+
+      expect(divA.childNodes.length).toBe(1);
+      expect(divA.childNodes[0].textContent).toBe("1");
+      expect(divB.childNodes.length).toBe(1);
+      expect(divB.lastChild).toBe(span2);
+    });
+  });
+
+  describe("append synchronization", () => {
+    it("should update innerHTML correctly", () => {
+      const doc = parseHTML("<div><span>A</span><span>B</span></div>");
+      const div = doc.querySelector("div");
+
+      const spanC = doc.createElement("span");
+      spanC.textContent = "C";
+
+      div.append(spanC);
+
+      expect(div.innerHTML).toBe("<span>A</span><span>B</span><span>C</span>");
+    });
+
+    it("should update innerHTML with multiple appends", () => {
+      const doc = parseHTML("<div><span>A</span></div>");
+      const div = doc.querySelector("div");
+
+      const spanB = doc.createElement("span");
+      spanB.textContent = "B";
+      const spanC = doc.createElement("span");
+      spanC.textContent = "C";
+
+      div.append(spanB, spanC);
+
+      expect(div.innerHTML).toBe("<span>A</span><span>B</span><span>C</span>");
+    });
+
+    it("should update textContent correctly", () => {
+      const doc = parseHTML("<div><span>First</span></div>");
+      const div = doc.querySelector("div");
+
+      div.append(" Second");
+
+      expect(div.textContent).toBe("First Second");
+    });
+  });
+
+  describe("append on document", () => {
+    it("should append to document", () => {
+      const doc = parseHTML("<div>Content</div>");
+      const div = doc.childNodes[0];
+
+      const newDiv = doc.createElement("div");
+      newDiv.textContent = "Last";
+
+      doc.append(newDiv);
+
+      expect(doc.lastChild).toBe(newDiv);
+      expect(div.nextSibling).toBe(newDiv);
+      expect(doc.childNodes.length).toBe(2);
+    });
+  });
+});
+
+describe("DOM Manipulation - remove", () => {
+  describe("Basic remove functionality", () => {
+    it("should remove an element from its parent", () => {
+      const doc = parseHTML("<div><span id='1'>First</span><span id='2'>Second</span></div>");
+      const div = doc.querySelector("div");
+      const span1 = doc.querySelector("#1");
+
+      span1.remove();
+
+      expect(div.childNodes.length).toBe(1);
+      expect(div.childNodes[0].textContent).toBe("Second");
+      expect(span1.parentNode).toBeNull();
+    });
+
+    it("should remove the only child", () => {
+      const doc = parseHTML("<div><span>Only</span></div>");
+      const div = doc.querySelector("div");
+      const span = div.querySelector("span");
+
+      span.remove();
+
+      expect(div.childNodes.length).toBe(0);
+      expect(div.firstChild).toBeNull();
+      expect(div.lastChild).toBeNull();
+      expect(span.parentNode).toBeNull();
+    });
+
+    it("should do nothing when element has no parent", () => {
+      const doc = parseHTML("<div></div>");
+      const orphan = doc.createElement("span");
+
+      expect(() => orphan.remove()).not.toThrow();
+      expect(orphan.parentNode).toBeNull();
+    });
+
+    it("should remove first child", () => {
+      const doc = parseHTML("<div><span>First</span><span>Second</span><span>Third</span></div>");
+      const div = doc.querySelector("div");
+      const first = div.childNodes[0];
+
+      first.remove();
+
+      expect(div.childNodes.length).toBe(2);
+      expect(div.firstChild.textContent).toBe("Second");
+      expect(div.childNodes[0].previousSibling).toBeNull();
+    });
+
+    it("should remove last child", () => {
+      const doc = parseHTML("<div><span>First</span><span>Second</span><span>Third</span></div>");
+      const div = doc.querySelector("div");
+      const last = div.childNodes[2];
+
+      last.remove();
+
+      expect(div.childNodes.length).toBe(2);
+      expect(div.lastChild.textContent).toBe("Second");
+      expect(div.childNodes[1].nextSibling).toBeNull();
+    });
+
+    it("should remove middle child", () => {
+      const doc = parseHTML("<div><span>First</span><span>Second</span><span>Third</span></div>");
+      const div = doc.querySelector("div");
+      const middle = div.childNodes[1];
+
+      middle.remove();
+
+      expect(div.childNodes.length).toBe(2);
+      expect(div.childNodes[0].textContent).toBe("First");
+      expect(div.childNodes[1].textContent).toBe("Third");
+    });
+  });
+
+  describe("remove sibling relationships", () => {
+    it("should update nextSibling and previousSibling correctly", () => {
+      const doc = parseHTML("<div><span>A</span><span>B</span><span>C</span></div>");
+      const div = doc.querySelector("div");
+      const spanA = div.childNodes[0];
+      const spanB = div.childNodes[1];
+      const spanC = div.childNodes[2];
+
+      spanB.remove();
+
+      expect(spanA.nextSibling).toBe(spanC);
+      expect(spanC.previousSibling).toBe(spanA);
+      expect(spanB.nextSibling).toBeNull();
+      expect(spanB.previousSibling).toBeNull();
+    });
+
+    it("should update element sibling relationships", () => {
+      const doc = parseHTML("<div><span>A</span><span>B</span><span>C</span></div>");
+      const div = doc.querySelector("div");
+      const spanA = div.childNodes[0];
+      const spanB = div.childNodes[1];
+      const spanC = div.childNodes[2];
+
+      spanB.remove();
+
+      expect(spanA.nextElementSibling).toBe(spanC);
+      expect(spanC.previousElementSibling).toBe(spanA);
+      expect(spanB.nextElementSibling).toBeNull();
+      expect(spanB.previousElementSibling).toBeNull();
+    });
+
+    it("should update parent references", () => {
+      const doc = parseHTML("<div><span>Child</span></div>");
+      const div = doc.querySelector("div");
+      const span = div.querySelector("span");
+
+      span.remove();
+
+      expect(span.parentNode).toBeNull();
+      expect(span.parentElement).toBeNull();
+    });
+  });
+
+  describe("remove text nodes", () => {
+    it("should remove text node", () => {
+      const doc = parseHTML("<div>Text content</div>");
+      const div = doc.querySelector("div");
+      const textNode = div.childNodes[0];
+
+      textNode.remove();
+
+      expect(div.childNodes.length).toBe(0);
+      expect(div.textContent).toBe("");
+      expect(textNode.parentNode).toBeNull();
+    });
+
+    it("should remove text node between elements", () => {
+      const doc = parseHTML("<div><span>A</span> text <span>B</span></div>");
+      const div = doc.querySelector("div");
+      const textNode = div.childNodes[1];
+
+      textNode.remove();
+
+      expect(div.childNodes.length).toBe(2);
+      expect(div.childNodes[0].nextSibling).toBe(div.childNodes[1]);
+    });
+  });
+
+  describe("remove synchronization", () => {
+    it("should update innerHTML correctly", () => {
+      const doc = parseHTML("<div><span>A</span><span>B</span><span>C</span></div>");
+      const div = doc.querySelector("div");
+      const spanB = div.childNodes[1];
+
+      spanB.remove();
+
+      expect(div.innerHTML).toBe("<span>A</span><span>C</span>");
+    });
+
+    it("should update textContent correctly", () => {
+      const doc = parseHTML("<div><span>First</span><span>Second</span></div>");
+      const div = doc.querySelector("div");
+      const second = div.childNodes[1];
+
+      second.remove();
+
+      expect(div.textContent).toBe("First");
+    });
+
+    it("should update children array correctly", () => {
+      const doc = parseHTML("<div><span>A</span><span>B</span><span>C</span></div>");
+      const div = doc.querySelector("div");
+      const spanB = div.children[1];
+
+      spanB.remove();
+
+      expect(div.children.length).toBe(2);
+      expect(div.children[0].textContent).toBe("A");
+      expect(div.children[1].textContent).toBe("C");
+    });
+  });
+
+  describe("remove multiple elements", () => {
+    it("should remove multiple elements sequentially", () => {
+      const doc = parseHTML("<div><span>A</span><span>B</span><span>C</span></div>");
+      const div = doc.querySelector("div");
+      const spanA = div.childNodes[0];
+      const spanB = div.childNodes[1];
+
+      spanA.remove();
+      spanB.remove();
+
+      expect(div.childNodes.length).toBe(1);
+      expect(div.childNodes[0].textContent).toBe("C");
+    });
+  });
+});

package/tests/official/acid/acid-tests.test.ts

@@ -233,7 +233,7 @@ describe('Performance Benchmarks', () => {
     const end = performance.now();
     
     expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(10); // Should be very fast
+    expect(end - start).toBeLessThan(10); 
   });
   
   it('should handle medium-sized HTML', () => {
@@ -245,7 +245,7 @@ describe('Performance Benchmarks', () => {
     const end = performance.now();
     
     expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(100); // Should still be fast
+    expect(end - start).toBeLessThan(100); 
   });
   
   it('should handle large HTML documents', () => {
@@ -257,7 +257,7 @@ describe('Performance Benchmarks', () => {
     const end = performance.now();
     
     expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(1000); // Should complete within 1 second
+    expect(end - start).toBeLessThan(1000); 
   });
   
   it('should handle deeply nested HTML', () => {
@@ -276,7 +276,7 @@ describe('Performance Benchmarks', () => {
     const end = performance.now();
     
     expect(ast).toBeDefined();
-    expect(end - start).toBeLessThan(500); // Should handle deep nesting
+    expect(end - start).toBeLessThan(500); 
   });
 });
 
@@ -284,14 +284,14 @@ describe('Memory Usage Tests', () => {
   it('should not leak memory on repeated parsing', () => {
     const testHtml = '<div><p>Memory test</p></div>';
     
-    // Parse the same HTML multiple times
+    
     for (let i = 0; i < 1000; i++) {
       const tokens = tokenize(testHtml);
       const ast = parse(tokens);
       expect(ast).toBeDefined();
     }
     
-    // If we get here without crashing, memory is likely managed well
+    
     expect(true).toBe(true);
   });