@dooboostore/dom-parser 1.0.0

package/src/node/elements/HTMLTableElement.ts

@@ -0,0 +1,117 @@
+import { Element } from './Element';
+import { Document } from '../Document';
+import { HTMLElement } from './HTMLElement';
+import { HTMLElementBase } from './HTMLElementBase';
+import { HTMLCollection } from '../collection/HTMLCollection'
+import { HTMLElementTagNameMap } from './index';
+
+/**
+ * The **`HTMLTableElement`** class represents an HTML `<table>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableElement)
+ */
+export class HTMLTableElement extends HTMLElementBase {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get caption(): HTMLElement | null {
+        return this.querySelector('caption');
+    }
+
+    get tHead(): HTMLElement | null {
+        return this.querySelector('thead');
+    }
+
+    get tFoot(): HTMLElement | null {
+        return this.querySelector('tfoot');
+    }
+
+    get tBodies(): HTMLCollection {
+        return this.querySelectorAll('tbody') as any;
+    }
+
+    get rows(): HTMLCollection {
+        return this.querySelectorAll('tr') as any;
+    }
+
+    createCaption(): HTMLElement {
+        let caption = this.caption;
+        if (!caption) {
+            caption = this.ownerDocument.createElement('caption');
+            this.insertBefore(caption, this.firstChild);
+        }
+        return caption;
+    }
+
+    deleteCaption(): void {
+        const caption = this.caption;
+        if (caption) {
+            this.removeChild(caption);
+        }
+    }
+
+    createTHead(): HTMLElement {
+        let thead = this.tHead;
+        if (!thead) {
+            thead = this.ownerDocument.createElement('thead');
+            const firstTBody = this.querySelector('tbody');
+            this.insertBefore(thead, firstTBody);
+        }
+        return thead;
+    }
+
+    deleteTHead(): void {
+        const thead = this.tHead;
+        if (thead) {
+            this.removeChild(thead);
+        }
+    }
+
+    createTFoot(): HTMLElement {
+        let tfoot = this.tFoot;
+        if (!tfoot) {
+            tfoot = this.ownerDocument.createElement('tfoot');
+            this.appendChild(tfoot);
+        }
+        return tfoot;
+    }
+
+    deleteTFoot(): void {
+        const tfoot = this.tFoot;
+        if (tfoot) {
+            this.removeChild(tfoot);
+        }
+    }
+
+    insertRow(index?: number): HTMLElement {
+        const row = this.ownerDocument.createElement('tr');
+        const rows = this.rows;
+        
+        if (index === undefined || index === -1) {
+            // Append to the end
+            const lastTBody = this.querySelector('tbody:last-child');
+            if (lastTBody) {
+                lastTBody.appendChild(row);
+            } else {
+                this.appendChild(row);
+            }
+        } else {
+            // Insert at specific index
+            if (index >= 0 && index < rows.length) {
+                const referenceRow = rows[index];
+                referenceRow.parentNode?.insertBefore(row, referenceRow);
+            }
+        }
+        
+        return row;
+    }
+
+    deleteRow(index: number): void {
+        const rows = this.rows;
+        if (index >= 0 && index < rows.length) {
+            const row = rows[index];
+            row.parentNode?.removeChild(row);
+        }
+    }
+}

package/src/node/elements/HTMLTbodyElement.ts

@@ -0,0 +1,46 @@
+import { HTMLElementBase } from './HTMLElementBase';
+import { HTMLCollection } from '../collection';
+import {HTMLElement} from "./HTMLElement";
+
+/**
+ * The **`HTMLTbodyElement`** class represents an HTML `<tbody>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableSectionElement)
+ */
+export class HTMLTbodyElement extends HTMLElementBase {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get rows(): HTMLCollection {
+        return this.querySelectorAll('tr') as any;
+    }
+
+    insertRow(index?: number): HTMLElement {
+        const row = this.ownerDocument.createElement('tr');
+        const rows = this.rows;
+        
+        if (index === undefined || index === -1) {
+            // Append to the end
+            this.appendChild(row);
+        } else {
+            // Insert at specific index
+            if (index >= 0 && index < rows.length) {
+                const referenceRow = rows[index];
+                this.insertBefore(row, referenceRow);
+            } else if (index >= rows.length) {
+                this.appendChild(row);
+            }
+        }
+
+        return row;
+    }
+
+    deleteRow(index: number): void {
+        const rows = this.rows;
+        if (index >= 0 && index < rows.length) {
+            const row = rows[index];
+            this.removeChild(row);
+        }
+    }
+}

package/src/node/elements/HTMLTdElement.ts

@@ -0,0 +1,67 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLTdElement`** class represents an HTML `<td>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableCellElement)
+ */
+export class HTMLTdElement extends HTMLElementBase {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get cellIndex(): number {
+        const row = this.parentElement;
+        if (!row) return -1;
+        
+        const cells = row.querySelectorAll('td, th');
+        for (let i = 0; i < cells.length; i++) {
+            if (cells[i] === this) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    get colSpan(): number {
+        const value = this.getAttribute('colspan');
+        return value ? parseInt(value, 10) : 1;
+    }
+
+    set colSpan(value: number) {
+        this.setAttribute('colspan', value.toString());
+    }
+
+    get rowSpan(): number {
+        const value = this.getAttribute('rowspan');
+        return value ? parseInt(value, 10) : 1;
+    }
+
+    set rowSpan(value: number) {
+        this.setAttribute('rowspan', value.toString());
+    }
+
+    get headers(): string {
+        return this.getAttribute('headers') || '';
+    }
+
+    set headers(value: string) {
+        this.setAttribute('headers', value);
+    }
+
+    get scope(): string {
+        return this.getAttribute('scope') || '';
+    }
+
+    set scope(value: string) {
+        this.setAttribute('scope', value);
+    }
+
+    get abbr(): string {
+        return this.getAttribute('abbr') || '';
+    }
+
+    set abbr(value: string) {
+        this.setAttribute('abbr', value);
+    }
+}

package/src/node/elements/HTMLTemplateElement.ts

@@ -0,0 +1,112 @@
+import { HTMLElementBase } from './HTMLElementBase';
+import { DocumentFragmentBase } from '../DocumentFragmentBase';
+import { Node, TEXT_NODE } from "../Node";
+import {Text} from '../Text'
+import {ElementFactory} from '../../factory/ElementFactory';
+import { NodeBase } from "../NodeBase";
+
+/**
+ * The **`HTMLTemplateElement`** class represents an HTML `<template>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTemplateElement)
+ */
+export class HTMLTemplateElement extends HTMLElementBase {
+    private _content: DocumentFragmentBase;
+    
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+        
+        // Create the content DocumentFragment
+        this._content = new DocumentFragmentBase(ownerDocument);
+        
+        // Parse innerHTML into the content fragment instead of the template itself
+        this._parseContentFromInnerHTML();
+    }
+
+    /**
+     * Gets the content DocumentFragment of the template.
+     */
+    get content(): DocumentFragmentBase {
+        return this._content;
+    }
+
+    /**
+     * Override innerHTML setter to populate the content fragment
+     */
+    set innerHTML(value: string) {
+        // Clear existing content
+        while (this._content.childNodes.length > 0) {
+            const child = this._content.childNodes[0];
+            if (child) {
+                this._content.removeChild(child);
+            }
+        }
+
+        // Parse HTML into content fragment
+        if (value.trim()) {
+            this._parseHTMLIntoContent(value);
+        }
+    }
+
+    /**
+     * Override innerHTML getter to return content fragment's innerHTML
+     */
+    get innerHTML(): string {
+        // Generate HTML from content fragment's children
+        let html = '';
+        for (let i = 0; i < this._content.childNodes.length; i++) {
+            const child = this._content.childNodes[i];
+            if (child && 'outerHTML' in child) {
+                html += (child as any).outerHTML;
+            } else if (child && child.nodeType === TEXT_NODE) {
+                html += (child as any).textContent || '';
+            } else if (child && child.nodeType === 8) { // COMMENT_NODE
+                html += `<!--${(child as any).textContent || ''}-->`;
+            }
+        }
+        return html;
+    }
+
+    /**
+     * Override appendChild to add children to both template and content
+     * Template elements can have direct children, and they're also copied to content
+     */
+    appendChild<T extends Node>(node: T): T {
+        // Add to template itself (like normal element)
+        const result = super.appendChild(node);
+        
+        // Also add a clone to the content fragment
+        if ('cloneNode' in node) {
+            this._content.appendChild((node as any).cloneNode(true));
+        }
+        
+        return result;
+    }
+
+    private _parseContentFromInnerHTML(): void {
+        // If template already has children from parsing, move them to content
+        const children = [...this._childNodesInternal];
+        for (const child of children) {
+            if (child) {
+                this.removeChild(child);
+                this._content.appendChild(child);
+            }
+        }
+    }
+
+    private _parseHTMLIntoContent(html: string): void {
+        // Better approach: Create a temporary container and leverage ElementBase's innerHTML
+        // This avoids code duplication and ensures consistency
+        const tempContainer = new (require('./ElementBase').ElementBase)('div', this._ownerDocument);
+        
+        // Use ElementBase's proven innerHTML parsing
+        tempContainer.innerHTML = html;
+        
+        // Move all parsed children to the content fragment
+        while (tempContainer.firstChild) {
+            this._content.appendChild(tempContainer.firstChild);
+        }
+    }
+
+
+}

package/src/node/elements/HTMLTfootElement.ts

@@ -0,0 +1,47 @@
+import { HTMLElementBase } from './HTMLElementBase';
+import { HTMLCollection } from '../collection';
+import { HTMLElement } from './HTMLElement';
+/**
+ * The **`HTMLTfootElement`** class represents an HTML `<tfoot>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableSectionElement)
+ */
+export class HTMLTfootElement extends HTMLElementBase {
+    static readonly TAG_NAME = 'TFOOT';
+    
+    constructor(ownerDocument?: any) {
+        super(HTMLTfootElement.TAG_NAME, ownerDocument);
+    }
+
+    get rows(): HTMLCollection {
+        return this.querySelectorAll('tr') as any;
+    }
+
+    insertRow(index?: number): HTMLElement {
+        const row = this.ownerDocument.createElement('tr');
+        const rows = this.rows;
+        
+        if (index === undefined || index === -1) {
+            // Append to the end
+            this.appendChild(row);
+        } else {
+            // Insert at specific index
+            if (index >= 0 && index < rows.length) {
+                const referenceRow = rows[index];
+                this.insertBefore(row, referenceRow);
+            } else if (index >= rows.length) {
+                this.appendChild(row);
+            }
+        }
+        
+        return row;
+    }
+
+    deleteRow(index: number): void {
+        const rows = this.rows;
+        if (index >= 0 && index < rows.length) {
+            const row = rows[index];
+            this.removeChild(row);
+        }
+    }
+}

package/src/node/elements/HTMLThElement.ts

@@ -0,0 +1,67 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLThElement`** class represents an HTML `<th>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableCellElement)
+ */
+export class HTMLThElement extends HTMLElementBase {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get cellIndex(): number {
+        const row = this.parentElement;
+        if (!row) return -1;
+        
+        const cells = row.querySelectorAll('td, th');
+        for (let i = 0; i < cells.length; i++) {
+            if (cells[i] === this) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    get colSpan(): number {
+        const value = this.getAttribute('colspan');
+        return value ? parseInt(value, 10) : 1;
+    }
+
+    set colSpan(value: number) {
+        this.setAttribute('colspan', value.toString());
+    }
+
+    get rowSpan(): number {
+        const value = this.getAttribute('rowspan');
+        return value ? parseInt(value, 10) : 1;
+    }
+
+    set rowSpan(value: number) {
+        this.setAttribute('rowspan', value.toString());
+    }
+
+    get headers(): string {
+        return this.getAttribute('headers') || '';
+    }
+
+    set headers(value: string) {
+        this.setAttribute('headers', value);
+    }
+
+    get scope(): string {
+        return this.getAttribute('scope') || '';
+    }
+
+    set scope(value: string) {
+        this.setAttribute('scope', value);
+    }
+
+    get abbr(): string {
+        return this.getAttribute('abbr') || '';
+    }
+
+    set abbr(value: string) {
+        this.setAttribute('abbr', value);
+    }
+}

package/src/node/elements/HTMLTheadElement.ts

@@ -0,0 +1,46 @@
+import {HTMLElementBase} from './HTMLElementBase';
+import {HTMLCollection} from '../collection';
+import {HTMLElement} from './HTMLElement';
+
+/**
+ * The **`HTMLTheadElement`** class represents an HTML `<thead>` element.
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableSectionElement)
+ */
+export class HTMLTheadElement extends HTMLElementBase {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get rows(): HTMLCollection {
+        return this.querySelectorAll('tr') as any;
+    }
+
+    insertRow(index?: number): HTMLElement {
+        const row = this.ownerDocument.createElement('tr');
+        const rows = this.rows;
+
+        if (index === undefined || index === -1) {
+            // Append to the end
+            this.appendChild(row);
+        } else {
+            // Insert at specific index
+            if (index >= 0 && index < rows.length) {
+                const referenceRow = rows[index];
+                this.insertBefore(row, referenceRow);
+            } else if (index >= rows.length) {
+                this.appendChild(row);
+            }
+        }
+
+        return row;
+    }
+
+    deleteRow(index: number): void {
+        const rows = this.rows;
+        if (index >= 0 && index < rows.length) {
+            const row = rows[index];
+            this.removeChild(row);
+        }
+    }
+}

package/src/node/elements/HTMLTitleElement.ts

@@ -0,0 +1,23 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLTitleElement`** class represents an HTML `<title>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTitleElement)
+ */
+export class HTMLTitleElement extends HTMLElementBase {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    /**
+     * Gets or sets the text content of the title element.
+     */
+    get text(): string {
+        return this.textContent || '';
+    }
+
+    set text(value: string) {
+        this.textContent = value;
+    }
+}

package/src/node/elements/HTMLTrElement.ts

@@ -0,0 +1,72 @@
+import { HTMLElement } from './HTMLElement';
+import { HTMLElementBase } from './HTMLElementBase';
+import { HTMLCollection, NodeListOf, NodeList, HTMLCollectionOf } from '../collection';
+/**
+ * The **`HTMLTrElement`** class represents an HTML `<tr>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLTableRowElement)
+ */
+export class HTMLTrElement extends HTMLElementBase {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get cells(): HTMLCollection {
+        return this.querySelectorAll('td, th') as any;
+    }
+
+    get rowIndex(): number {
+        const table = this.closest('table');
+        if (!table) return -1;
+        
+        const allRows = table.querySelectorAll('tr');
+        for (let i = 0; i < allRows.length; i++) {
+            const a = allRows[i];
+            if (allRows[i] === this) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    get sectionRowIndex(): number {
+        const section = this.parentElement;
+        if (!section) return -1;
+        
+        const sectionRows = section.querySelectorAll('tr');
+        for (let i = 0; i < sectionRows.length; i++) {
+            if (sectionRows[i] === this) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    insertCell(index?: number): HTMLElement {
+        const cell = this.ownerDocument.createElement('td');
+        const cells = this.cells;
+        
+        if (index === undefined || index === -1) {
+            // Append to the end
+            this.appendChild(cell);
+        } else {
+            // Insert at specific index
+            if (index >= 0 && index < cells.length) {
+                const referenceCell = cells[index];
+                this.insertBefore(cell, referenceCell);
+            } else if (index >= cells.length) {
+                this.appendChild(cell);
+            }
+        }
+        
+        return cell;
+    }
+
+    deleteCell(index: number): void {
+        const cells = this.cells;
+        if (index >= 0 && index < cells.length) {
+            const cell = cells[index];
+            this.removeChild(cell);
+        }
+    }
+}

package/src/node/elements/HTMLUListElement.ts

@@ -0,0 +1,12 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLUListElement`** class represents an HTML `<ul>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLUListElement)
+ */
+export class HTMLUListElement extends HTMLElementBase {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+}

package/src/node/elements/MathMLElement.ts

@@ -0,0 +1,16 @@
+import { ElementBase } from './ElementBase';
+
+/**
+ * The **`MathMLElement`** class represents the base class for all MathML elements.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/MathMLElement)
+ */
+export class MathMLElement extends ElementBase {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName.toUpperCase(), ownerDocument);
+    }
+
+    get namespaceURI(): string | null {
+        return 'http://www.w3.org/1998/Math/MathML';
+    }
+}

package/src/node/elements/SVGCircleElement.ts

@@ -0,0 +1,61 @@
+import { SVGElement } from './SVGElement';
+
+/**
+ * The **`SVGCircleElement`** class represents an SVG `<circle>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/SVGCircleElement)
+ */
+export class SVGCircleElement extends SVGElement {
+    private _cx: number = 0;
+    private _cy: number = 0;
+    private _r: number = 0;
+
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get cx(): number {
+        return this._cx;
+    }
+
+    set cx(value: number) {
+        this._cx = value;
+        this.setAttribute('cx', value.toString());
+    }
+
+    get cy(): number {
+        return this._cy;
+    }
+
+    set cy(value: number) {
+        this._cy = value;
+        this.setAttribute('cy', value.toString());
+    }
+
+    get r(): number {
+        return this._r;
+    }
+
+    set r(value: number) {
+        this._r = value;
+        this.setAttribute('r', value.toString());
+    }
+
+    // Override setAttribute to sync with properties
+    setAttribute(qualifiedName: string, value: string): void {
+        super.setAttribute(qualifiedName, value);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'cx':
+                this._cx = parseFloat(value) || 0;
+                break;
+            case 'cy':
+                this._cy = parseFloat(value) || 0;
+                break;
+            case 'r':
+                this._r = parseFloat(value) || 0;
+                break;
+        }
+    }
+}