@dooboostore/dom-parser 1.0.0

package/src/node/ParentNode.ts

@@ -0,0 +1,93 @@
+import { Node } from './Node';
+import { NodeListOf } from './collection/NodeListOf';
+import { HTMLCollection } from './collection/HTMLCollection';
+import { Element } from './elements/Element';
+import {HTMLElementDeprecatedTagNameMap, HTMLElementTagNameMap, MathMLElementTagNameMap, SVGElementTagNameMap} from "./elements";
+
+/**
+ * The **`ParentNode`** interface contains methods and properties that are common to all types of Node objects that can have children.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ParentNode)
+ */
+export interface ParentNode extends Node {
+    /**
+     * Returns the number of child elements of this ParentNode.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/childElementCount)
+     */
+    readonly childElementCount: number;
+
+    /**
+     * Returns the child elements.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/children)
+     */
+    readonly children: HTMLCollection;
+
+    /**
+     * Returns the first child that is an element, and null otherwise.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/firstElementChild)
+     */
+    readonly firstElementChild: Element | null;
+
+    /**
+     * Returns the last child that is an element, and null otherwise.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/lastElementChild)
+     */
+    readonly lastElementChild: Element | null;
+
+    /**
+     * Inserts nodes after the last child of node, while replacing strings in nodes with equivalent Text nodes.
+     *
+     * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/append)
+     */
+    append(...nodes: (Node | string)[]): void;
+
+    /**
+     * Inserts nodes before the first child of node, while replacing strings in nodes with equivalent Text nodes.
+     *
+     * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/prepend)
+     */
+    prepend(...nodes: (Node | string)[]): void;
+
+    /**
+     * Returns the first element that is a descendant of node that matches selectors.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/querySelector)
+     */
+    querySelector<K extends keyof HTMLElementTagNameMap>(selectors: K): HTMLElementTagNameMap[K] | null;
+    querySelector<K extends keyof SVGElementTagNameMap>(selectors: K): SVGElementTagNameMap[K] | null;
+    querySelector<K extends keyof MathMLElementTagNameMap>(selectors: K): MathMLElementTagNameMap[K] | null;
+    /** @deprecated */
+    querySelector<K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): HTMLElementDeprecatedTagNameMap[K] | null;
+    querySelector<E extends Element = Element>(selectors: string): E | null;
+    querySelector(selectors: string): Element | null;
+
+    /**
+     * Returns all element descendants of node that match selectors.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/querySelectorAll)
+     */
+    querySelectorAll<K extends keyof HTMLElementTagNameMap>(selectors: K): NodeListOf<HTMLElementTagNameMap[K]>;
+    querySelectorAll<K extends keyof SVGElementTagNameMap>(selectors: K): NodeListOf<SVGElementTagNameMap[K]>;
+    querySelectorAll<K extends keyof MathMLElementTagNameMap>(selectors: K): NodeListOf<MathMLElementTagNameMap[K]>;
+    /** @deprecated */
+    querySelectorAll<K extends keyof HTMLElementDeprecatedTagNameMap>(selectors: K): NodeListOf<HTMLElementDeprecatedTagNameMap[K]>;
+    querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
+    querySelectorAll(selectors: string): NodeListOf<Element>;
+
+    /**
+     * Replace all children of node with nodes, while replacing strings in nodes with equivalent Text nodes.
+     *
+     * Throws a "HierarchyRequestError" DOMException if the constraints of the node tree are violated.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Document/replaceChildren)
+     */
+    replaceChildren(...nodes: (Node | string)[]): void;
+}

package/src/node/ParentNodeBase.ts

@@ -0,0 +1,145 @@
+import { Node } from './Node';
+import { ChildNodeBase } from './ChildNodeBase';
+import { ParentNode } from './ParentNode';
+import { Element } from './elements/Element';
+import { HTMLCollection } from './collection/HTMLCollection';
+import { NodeListOf } from './collection/NodeListOf';
+import { ELEMENT_NODE, TEXT_NODE } from './Node';
+import { TextBase } from './TextBase';
+import { CSSSelector } from '../utils/CSSSelector';
+
+/**
+ * Base implementation of the ParentNode interface
+ */
+export abstract class ParentNodeBase extends ChildNodeBase implements ParentNode {
+
+    // ParentNode interface implementation
+    get childElementCount(): number {
+        let count = 0;
+        for (const child of this._childNodesInternal) {
+            if (child && child.nodeType === ELEMENT_NODE) {
+                count++;
+            }
+        }
+        return count;
+    }
+
+    get children(): HTMLCollection {
+        const elements: Element[] = [];
+        for (const child of this._childNodesInternal) {
+            if (child && child.nodeType === ELEMENT_NODE) {
+                elements.push(child as unknown as Element);
+            }
+        }
+        return new HTMLCollection(elements);
+    }
+
+    get firstElementChild(): Element | null {
+        for (const child of this._childNodesInternal) {
+            if (child && child.nodeType === ELEMENT_NODE) {
+                return child as unknown as Element;
+            }
+        }
+        return null;
+    }
+
+    get lastElementChild(): Element | null {
+        for (let i = this._childNodesInternal.length - 1; i >= 0; i--) {
+            const child = this._childNodesInternal[i];
+            if (child && child.nodeType === ELEMENT_NODE) {
+                return child as unknown as Element;
+            }
+        }
+        return null;
+    }
+
+    append(...nodes: (Node | string)[]): void {
+        for (const node of nodes) {
+            if (typeof node === 'string') {
+                const textNode = new TextBase(node, this._ownerDocument);
+                this.appendChild(textNode);
+            } else {
+                this.appendChild(node);
+            }
+        }
+    }
+
+    prepend(...nodes: (Node | string)[]): void {
+        const firstChild = this.firstChild;
+        for (const node of nodes) {
+            if (typeof node === 'string') {
+                const textNode = new TextBase(node, this._ownerDocument);
+                this.insertBefore(textNode, firstChild);
+            } else {
+                this.insertBefore(node, firstChild);
+            }
+        }
+    }
+
+    replaceChildren(...nodes: (Node | string)[]): void {
+        // Remove all existing children
+        while (this._childNodesInternal.length > 0) {
+            const child = this._childNodesInternal[0];
+            if (child) {
+                this.removeChild(child);
+            }
+        }
+
+        // Add new nodes
+        this.append(...nodes);
+    }
+
+    // Query selector implementation
+    querySelector<E extends Element>(selectors: string): E | null {
+        const elements = this.querySelectorAll(selectors);
+        return elements.length > 0 ? elements.item(0) as E: null;
+    }
+
+    querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E> {
+        const results: E[] = [];
+        
+        // Split selectors by comma and process each one
+        const selectorList = selectors.split(',').map(s => s.trim());
+        
+        for (const selector of selectorList) {
+            if (selector) {
+                this._querySelectorAllRecursive(selector, results);
+            }
+        }
+        
+        // Remove duplicates while preserving order
+        const uniqueResults: E[] = [];
+        const seen = new Set();
+        for (const element of results) {
+            if (!seen.has(element)) {
+                seen.add(element);
+                uniqueResults.push(element);
+            }
+        }
+        
+        return new NodeListOf<E>(uniqueResults);
+    }
+
+    // Private helper methods for querySelector
+    private _querySelectorAllRecursive(selectors: string, results: Element[]): void {
+        for (const child of this._childNodesInternal) {
+            if (child && child.nodeType === ELEMENT_NODE) {
+                const element = child as unknown as Element;
+
+                // Check if this element matches the selector
+                if (CSSSelector.matches(element, selectors)) {
+                    results.push(element);
+                }
+
+                // Recursively search in child elements
+                if (child instanceof ParentNodeBase) {
+                    child._querySelectorAllRecursive(selectors, results);
+                }
+            }
+        }
+    }
+
+
+}
+
+// TextNode is now in a separate file

package/src/node/Text.ts

@@ -0,0 +1,30 @@
+import { CharacterData } from './CharacterData';
+import { ChildNode } from './ChildNode';
+import {TEXT_NODE} from "./Node";
+
+/**
+ * The **`Text`** interface represents a text node in the DOM.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Text)
+ */
+export interface Text extends CharacterData, ChildNode {
+    readonly nodeType: typeof TEXT_NODE; // TEXT_NODE
+    readonly nodeName: '#text';
+    
+    /**
+     * The **`Text.splitText()`** method breaks the Text node into two nodes at the specified offset, keeping both nodes in the tree as siblings.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Text/splitText)
+     */
+    splitText(offset: number): Text;
+    
+    /**
+     * The **`Text.wholeText`** read-only property returns the full text of all Text nodes logically adjacent to the node.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Text/wholeText)
+     */
+    readonly wholeText: string;
+}
+
+// Note: TextBase is the implementation class for this interface
+

package/src/node/TextBase.ts

@@ -0,0 +1,113 @@
+import { ChildNodeBase } from './ChildNodeBase';
+import { TEXT_NODE } from './Node';
+import { Text } from './Text';
+
+/**
+ * The **`TextBase`** class represents a text node implementation in the DOM.
+ */
+export class TextBase extends ChildNodeBase implements Text {
+    private _data: string;
+    
+    // Override nodeType to match Text interface
+    readonly nodeType: 3 = TEXT_NODE as 3;
+    readonly nodeName: '#text' = '#text';
+
+    constructor(data: string, ownerDocument?: any) {
+        super(TEXT_NODE, '#text', ownerDocument);
+        this._data = data;
+        this._nodeValue = data;
+    }
+
+    get data(): string {
+        return this._data;
+    }
+
+    set data(value: string) {
+        this._data = value;
+        this._nodeValue = value;
+    }
+
+    get length(): number {
+        return this._data.length;
+    }
+
+    get textContent(): string | null {
+        // Decode HTML entities to return original text
+        return this._data ? this.decodeHTMLEntities(this._data) : this._data;
+    }
+
+    set textContent(value: string | null) {
+        this._data = value || '';
+        this._nodeValue = this._data;
+    }
+
+    get wholeText(): string {
+        // For now, just return the current text
+        // In a full implementation, this would collect adjacent text nodes
+        return this._data;
+    }
+
+    // CharacterData methods
+    appendData(data: string): void {
+        this._data += data;
+        this._nodeValue = this._data;
+    }
+
+    deleteData(offset: number, count: number): void {
+        if (offset < 0 || offset > this._data.length) {
+            throw new Error('Index out of bounds');
+        }
+        const endOffset = Math.min(offset + count, this._data.length);
+        this._data = this._data.slice(0, offset) + this._data.slice(endOffset);
+        this._nodeValue = this._data;
+    }
+
+    insertData(offset: number, data: string): void {
+        if (offset < 0 || offset > this._data.length) {
+            throw new Error('Index out of bounds');
+        }
+        this._data = this._data.slice(0, offset) + data + this._data.slice(offset);
+        this._nodeValue = this._data;
+    }
+
+    replaceData(offset: number, count: number, data: string): void {
+        this.deleteData(offset, count);
+        this.insertData(offset, data);
+    }
+
+    substringData(offset: number, count: number): string {
+        if (offset < 0 || offset > this._data.length) {
+            throw new Error('Index out of bounds');
+        }
+        const endOffset = Math.min(offset + count, this._data.length);
+        return this._data.slice(offset, endOffset);
+    }
+
+    splitText(offset: number): Text {
+        if (offset < 0 || offset > this._data.length) {
+            throw new Error('Index out of bounds');
+        }
+
+        const newData = this._data.slice(offset);
+        this._data = this._data.slice(0, offset);
+        this._nodeValue = this._data;
+
+        const newTextNode = new TextBase(newData, this._ownerDocument);
+
+        // Insert the new text node after this one
+        if (this._parentNodeInternal) {
+            const nextSibling = this.nextSibling;
+            this._parentNodeInternal.insertBefore(newTextNode, nextSibling);
+        }
+
+        return newTextNode as Text;
+    }
+
+    cloneNode(deep?: boolean): Text {
+        return new TextBase(this._data, this._ownerDocument) as Text;
+    }
+
+    toString(): string {
+        return this._data;
+    }
+}

package/src/node/collection/HTMLCollection.ts

@@ -0,0 +1,107 @@
+import { Element } from '../elements/Element';
+
+/**
+ * **`HTMLCollection`** represents a generic collection of HTML elements.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLCollection)
+ */
+export class HTMLCollection {
+    // 인덱스 시그니처 선언
+    [index: number]: Element;
+    
+    private _elements: Element[] = [];
+
+    constructor(elements: Element[] = []) {
+        this._elements = [...elements];
+        
+        // 인덱스 시그니처 구현을 위한 프록시 설정
+        return new Proxy(this, {
+            get(target, prop) {
+                // 숫자 인덱스인 경우
+                if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+                    const index = parseInt(prop, 10);
+                    return target._elements[index] || null;
+                }
+                // 일반 프로퍼티/메서드인 경우
+                return (target as any)[prop];
+            },
+            
+            set(target, prop, value) {
+                // 숫자 인덱스 설정 방지 (읽기 전용)
+                if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+                    return false;
+                }
+                (target as any)[prop] = value;
+                return true;
+            },
+            
+            has(target, prop) {
+                if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+                    const index = parseInt(prop, 10);
+                    return index >= 0 && index < target._elements.length;
+                }
+                return prop in target;
+            }
+        });
+    }
+
+    /**
+     * Returns the number of elements in the collection.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLCollection/length)
+     */
+    get length(): number {
+        return this._elements.length;
+    }
+
+    /**
+     * Returns the element at the specified index, or null if the index is out of range.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLCollection/item)
+     */
+    item(index: number): Element | null {
+        if (index < 0 || index >= this._elements.length) {
+            return null;
+        }
+        return this._elements[index];
+    }
+
+    /**
+     * Returns the element with the specified ID or name, or null if no such element exists.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLCollection/namedItem)
+     */
+    namedItem(name: string): Element | null {
+        for (const element of this._elements) {
+            if (element.id === name || element.getAttribute('name') === name) {
+                return element;
+            }
+        }
+        return null;
+    }
+
+    /**
+     * Returns an iterator for the collection.
+     */
+    [Symbol.iterator](): IterableIterator<Element> {
+        return this._elements[Symbol.iterator]();
+    }
+
+    // 내부적으로 요소 추가/제거를 위한 메서드들 (DOM 조작 시 사용)
+    _addElement(element: Element): void {
+        this._elements.push(element);
+    }
+
+    _removeElement(element: Element): boolean {
+        const index = this._elements.indexOf(element);
+        if (index !== -1) {
+            this._elements.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+
+    _insertElement(index: number, element: Element): void {
+        this._elements.splice(index, 0, element);
+    }
+}

package/src/node/collection/HTMLCollectionOf.ts

@@ -0,0 +1,26 @@
+import { Element } from '../elements/Element';
+import { HTMLCollection } from './HTMLCollection';
+
+/**
+ * **`HTMLCollectionOf<T>`** is a generic version of HTMLCollection that provides type safety for specific element types.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLCollection)
+ */
+export class HTMLCollectionOf<T extends Element> extends HTMLCollection {
+    // 인덱스 시그니처를 명시적으로 선언하여 타입 추론 지원
+    [index: number]: T;
+    
+    constructor(elements: T[] = []) {
+        // 부모 HTMLCollection의 생성자를 호출하면서 타입이 지정된 요소들을 전달
+        super(elements as Element[]);
+    }
+
+    // 타입 안전성을 위한 오버라이드 - 단순 캐스팅만
+    item(index: number): T | null {
+        return super.item(index) as T | null;
+    }
+
+    namedItem(name: string): T | null {
+        return super.namedItem(name) as T | null;
+    }
+}

package/src/node/collection/NodeList.ts

@@ -0,0 +1,140 @@
+import { Node } from '../Node';
+
+/**
+ * **`NodeList`** objects are collections of nodes, usually returned by properties such as Node.childNodes and methods such as document.querySelectorAll().
+ *
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NodeList)
+ */
+export class NodeList<T extends Node = Node> {
+    // 인덱스 시그니처 선언
+    [index: number]: T;
+    
+    private _nodes: T[] = [];
+
+    constructor(nodes: T[] = []) {
+        this._nodes = [...nodes];
+        
+        // 인덱스 시그니처 구현을 위한 프록시 설정
+        return new Proxy(this, {
+            get(target, prop) {
+                // 숫자 인덱스인 경우
+                if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+                    const index = parseInt(prop, 10);
+                    return target._nodes[index] || null;
+                }
+                // 일반 프로퍼티/메서드인 경우
+                return (target as any)[prop];
+            },
+            
+            set(target, prop, value) {
+                // 숫자 인덱스 설정 방지 (읽기 전용)
+                if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+                    return false;
+                }
+                (target as any)[prop] = value;
+                return true;
+            },
+            
+            has(target, prop) {
+                if (typeof prop === 'string' && /^\d+$/.test(prop)) {
+                    const index = parseInt(prop, 10);
+                    return index >= 0 && index < target._nodes.length;
+                }
+                return prop in target;
+            }
+        });
+    }
+
+    /**
+     * The **`NodeList.length`** property returns the number of items in a NodeList.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NodeList/length)
+     */
+    get length(): number {
+        return this._nodes.length;
+    }
+
+    /**
+     * Returns a node from a `NodeList` by index.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NodeList/item)
+     */
+    item(index: number): T | null {
+        if (index < 0 || index >= this._nodes.length) {
+            return null;
+        }
+        return this._nodes[index];
+    }
+
+    /**
+     * Executes a provided function once for each `Node` value in the `NodeList`.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NodeList/forEach)
+     */
+    forEach(callbackfn: (value: T, key: number, parent: NodeList) => void, thisArg?: any): void {
+        this._nodes.forEach((node, index) => {
+            callbackfn.call(thisArg, node, index, this);
+        });
+    }
+
+    // 내부적으로 노드 추가/제거를 위한 메서드들 (DOM 조작 시 사용)
+    _addNode(node: T): void {
+        this._nodes.push(node);
+    }
+
+    _removeNode(node: T): boolean {
+        const index = this._nodes.indexOf(node);
+        if (index !== -1) {
+            this._nodes.splice(index, 1);
+            return true;
+        }
+        return false;
+    }
+
+    _insertNode(index: number, node: T): void {
+        this._nodes.splice(index, 0, node);
+    }
+
+    // Iterator 지원 (for...of 사용 가능)
+    *[Symbol.iterator](): Iterator<T> {
+        for (const node of this._nodes) {
+            yield node;
+        }
+    }
+
+    /**
+     * Returns an iterator allowing to go through all keys contained in this object.
+     * The keys are unsigned integer (index).
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NodeList/keys)
+     */
+    *keys(): IterableIterator<number> {
+        for (let i = 0; i < this._nodes.length; i++) {
+            yield i;
+        }
+    }
+
+    /**
+     * Returns an iterator allowing to go through all values contained in this object.
+     * The values are Node objects.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NodeList/values)
+     */
+    *values(): IterableIterator<T> {
+        for (const node of this._nodes) {
+            yield node;
+        }
+    }
+
+    /**
+     * Returns an iterator allowing to go through all key/value pairs contained in this object.
+     * The key is an unsigned integer (index) and the value is a Node object.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NodeList/entries)
+     */
+    *entries(): IterableIterator<[number, T]> {
+        for (let i = 0; i < this._nodes.length; i++) {
+            yield [i, this._nodes[i]];
+        }
+    }
+}

package/src/node/collection/NodeListOf.ts

@@ -0,0 +1,28 @@
+import { Node } from '../Node';
+import { NodeList } from './NodeList';
+
+/**
+ * **`NodeListOf<TNode>`** is a generic version of NodeList that provides type safety for specific node types.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/NodeList)
+ */
+export class NodeListOf<TNode extends Node> extends NodeList<TNode> {
+    // 인덱스 시그니처를 명시적으로 선언하여 타입 추론 지원
+    [index: number]: TNode;
+    
+    constructor(nodes: TNode[] = []) {
+        // 부모 NodeList의 생성자를 호출하면서 타입이 지정된 노드들을 전달
+        super(nodes as TNode[]);
+    }
+
+    // 타입 안전성을 위한 오버라이드 - 단순 캐스팅만
+    item(index: number): TNode | null {
+        return super.item(index) as TNode | null;
+    }
+
+    forEach(callbackfn: (value: TNode, key: number, parent: NodeListOf<TNode>) => void, thisArg?: any): void {
+        super.forEach((node, index) => {
+            callbackfn.call(thisArg, node as TNode, index, this);
+        }, thisArg);
+    }
+}

package/src/node/collection/index.ts

@@ -0,0 +1,4 @@
+export { HTMLCollection } from './HTMLCollection';
+export { HTMLCollectionOf } from './HTMLCollectionOf';
+export { NodeList } from './NodeList';
+export { NodeListOf } from './NodeListOf';