@dooboostore/dom-parser 1.0.2 → 1.0.3

package/src/node/ShadowRootBase.ts

@@ -0,0 +1,87 @@
+import { DocumentFragmentBase } from './DocumentFragmentBase';
+
+/**
+ * The **`ShadowRoot`** interface represents the root node of a shadow DOM subtree.
+ */
+// @ts-ignore
+export class ShadowRootBase extends DocumentFragmentBase implements ShadowRoot {
+  public readonly delegatesFocus: boolean;
+  public readonly mode: ShadowRootMode;
+  public readonly slotAssignment: SlotAssignmentMode;
+  private _host: Element;
+
+  constructor(host: Element, init: { mode: ShadowRootMode; delegatesFocus?: boolean; slotAssignment?: SlotAssignmentMode }, ownerDocument?: Document) {
+    super(ownerDocument);
+    this._host = host;
+    this.mode = init.mode;
+    this.delegatesFocus = init.delegatesFocus || false;
+    this.slotAssignment = init.slotAssignment || 'manual';
+
+    // Set nodeName to '#shadow-root'
+    (this as any).nodeName = '#shadow-root';
+  }
+
+  clonable: boolean;
+    onslotchange: (this: ShadowRoot, ev: Event) => any;
+    serializable: boolean;
+    getHTML(options?: GetHTMLOptions): string {
+        throw new Error("Method not implemented.");
+    }
+    setHTMLUnsafe(html: string): void {
+        throw new Error("Method not implemented.");
+    }
+    activeElement: Element;
+    adoptedStyleSheets: CSSStyleSheet[];
+    fullscreenElement: Element;
+    pictureInPictureElement: Element;
+    pointerLockElement: Element;
+    styleSheets: StyleSheetList;
+    elementFromPoint(x: number, y: number): Element | null {
+        throw new Error("Method not implemented.");
+    }
+    elementsFromPoint(x: number, y: number): Element[] {
+        throw new Error("Method not implemented.");
+    }
+    getAnimations(): Animation[] {
+        throw new Error("Method not implemented.");
+    }
+
+  get host(): Element {
+    return this._host;
+  }
+
+  /**
+   * innerHTML for ShadowRoot
+   */
+  get innerHTML(): string {
+    let html = '';
+    for (const child of this._childNodesInternal) {
+      if ((child as any).nodeType === 3) {
+        // TEXT_NODE
+        html += (child as any)._nodeValue || '';
+      } else if ((child as any).nodeType === 1) {
+        // ELEMENT_NODE
+        html += (this._host as any).generateChildElementHTML(child as any);
+      } else if ((child as any).nodeType === 8) {
+        // COMMENT_NODE
+        html += `<!--${(child as any).textContent || ''}-->`;
+      }
+    }
+    return html;
+  }
+
+  set innerHTML(value: string) {
+    // Clear existing children
+    while (this._childNodesInternal.length > 0) {
+      const child = this._childNodesInternal[0];
+      if (child) {
+        this.removeChild(child as unknown as Node);
+      }
+    }
+
+    // Parse HTML and create child nodes
+    if (value.trim()) {
+      (this._host as any).parseAndAppendHTML(value, this);
+    }
+  }
+}

package/src/node/Text.ts

@@ -1,30 +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
-
+// // 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

@@ -1,113 +1,111 @@
 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;
+  private _data: string;
+
+  declare nodeType: 3;
+  declare nodeName: '#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');
     }
-
-    get data(): string {
-        return this._data;
+    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');
     }
-
-    set data(value: string) {
-        this._data = value;
-        this._nodeValue = value;
+    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);
+  }
 
-    get length(): number {
-        return this._data.length;
+  splitText(offset: number): Text {
+    if (offset < 0 || offset > this._data.length) {
+      throw new Error('Index out of bounds');
     }
 
-    get textContent(): string | null {
-        // Decode HTML entities to return original text
-        return this._data ? this.decodeHTMLEntities(this._data) : this._data;
-    }
+    const newData = this._data.slice(offset);
+    this._data = this._data.slice(0, offset);
+    this._nodeValue = this._data;
 
-    set textContent(value: string | null) {
-        this._data = value || '';
-        this._nodeValue = this._data;
-    }
+    const newTextNode = new TextBase(newData, this._ownerDocument);
 
-    get wholeText(): string {
-        // For now, just return the current text
-        // In a full implementation, this would collect adjacent text nodes
-        return this._data;
+    // Insert the new text node after this one
+    if (this._parentNodeInternal) {
+      const nextSibling = this.nextSibling;
+      this._parentNodeInternal.insertBefore(newTextNode, nextSibling);
     }
 
-    // CharacterData methods
-    appendData(data: string): void {
-        this._data += data;
-        this._nodeValue = this._data;
-    }
+    return newTextNode as Text;
+  }
 
-    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;
-    }
+  cloneNode(deep?: boolean): Text {
+    return new TextBase(this._data, this._ownerDocument) as Text;
+  }
 
-    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;
-    }
-}
+  toString(): string {
+    return this._data;
+  }
+}

package/src/node/TreeWalker.ts

@@ -0,0 +1,280 @@
+import {NodeFilter} from "./NodeFilter";
+
+/**
+ * TreeWalker implementation for traversing DOM nodes
+ */
+export class TreeWalker {
+  private _root: Node;
+  private _whatToShow: number;
+  private _filter: NodeFilter | null;
+  private _currentNode: Node;
+
+  constructor(root: Node, whatToShow: number = NodeFilter.SHOW_ALL, filter: NodeFilter | null = null) {
+    this._root = root;
+    this._whatToShow = whatToShow;
+    this._filter = filter;
+    this._currentNode = root;
+  }
+
+  get root(): Node {
+    return this._root;
+  }
+
+  get whatToShow(): number {
+    return this._whatToShow;
+  }
+
+  get filter(): NodeFilter | null {
+    return this._filter;
+  }
+
+  get currentNode(): Node {
+    return this._currentNode;
+  }
+
+  set currentNode(node: Node) {
+    this._currentNode = node;
+  }
+
+  /**
+   * Move to the parent node
+   */
+  parentNode(): Node | null {
+    let node = this._currentNode;
+    while (node && node !== this._root) {
+      node = (node as any).parentNode;
+      if (node && this._acceptNode(node) === NodeFilter.FILTER_ACCEPT) {
+        this._currentNode = node;
+        return node;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Move to the first child node
+   */
+  firstChild(): Node | null {
+    let node = (this._currentNode as any).firstChild;
+    while (node) {
+      const result = this._acceptNode(node);
+      if (result === NodeFilter.FILTER_ACCEPT) {
+        this._currentNode = node;
+        return node;
+      }
+      if (result === NodeFilter.FILTER_SKIP) {
+        const child = (node as any).firstChild;
+        if (child) {
+          node = child;
+          continue;
+        }
+      }
+      while (node) {
+        const next = (node as any).nextSibling;
+        if (next) {
+          node = next;
+          break;
+        }
+        const parent = (node as any).parentNode;
+        if (!parent || parent === this._root || parent === this._currentNode) {
+          return null;
+        }
+        node = parent;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Move to the last child node
+   */
+  lastChild(): Node | null {
+    let node = (this._currentNode as any).lastChild;
+    while (node) {
+      const result = this._acceptNode(node);
+      if (result === NodeFilter.FILTER_ACCEPT) {
+        this._currentNode = node;
+        return node;
+      }
+      if (result === NodeFilter.FILTER_SKIP) {
+        const child = (node as any).lastChild;
+        if (child) {
+          node = child;
+          continue;
+        }
+      }
+      while (node) {
+        const prev = (node as any).previousSibling;
+        if (prev) {
+          node = prev;
+          break;
+        }
+        const parent = (node as any).parentNode;
+        if (!parent || parent === this._root || parent === this._currentNode) {
+          return null;
+        }
+        node = parent;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Move to the previous sibling node
+   */
+  previousSibling(): Node | null {
+    let node = this._currentNode;
+    if (node === this._root) return null;
+
+    while (node) {
+      let sibling = (node as any).previousSibling;
+      while (sibling) {
+        const result = this._acceptNode(sibling);
+        if (result === NodeFilter.FILTER_ACCEPT) {
+          this._currentNode = sibling;
+          return sibling;
+        }
+        if (result === NodeFilter.FILTER_SKIP) {
+          const lastChild = (sibling as any).lastChild;
+          if (lastChild) {
+            sibling = lastChild;
+            continue;
+          }
+        }
+        sibling = (sibling as any).previousSibling;
+      }
+      node = (node as any).parentNode;
+      if (!node || node === this._root || this._acceptNode(node) === NodeFilter.FILTER_ACCEPT) {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Move to the next sibling node
+   */
+  nextSibling(): Node | null {
+    let node = this._currentNode;
+    if (node === this._root) return null;
+
+    while (node) {
+      let sibling = (node as any).nextSibling;
+      while (sibling) {
+        const result = this._acceptNode(sibling);
+        if (result === NodeFilter.FILTER_ACCEPT) {
+          this._currentNode = sibling;
+          return sibling;
+        }
+        if (result === NodeFilter.FILTER_SKIP) {
+          const firstChild = (sibling as any).firstChild;
+          if (firstChild) {
+            sibling = firstChild;
+            continue;
+          }
+        }
+        sibling = (sibling as any).nextSibling;
+      }
+      node = (node as any).parentNode;
+      if (!node || node === this._root || this._acceptNode(node) === NodeFilter.FILTER_ACCEPT) {
+        return null;
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Move to the previous node in document order
+   */
+  previousNode(): Node | null {
+    let node = this._currentNode;
+    while (node && node !== this._root) {
+      const sibling = (node as any).previousSibling;
+      if (sibling) {
+        node = sibling;
+        while (true) {
+          const result = this._acceptNode(node);
+          if (result !== NodeFilter.FILTER_REJECT && (node as any).lastChild) {
+            node = (node as any).lastChild;
+          } else {
+            if (result === NodeFilter.FILTER_ACCEPT) {
+              this._currentNode = node;
+              return node;
+            }
+            break;
+          }
+        }
+        continue;
+      }
+
+      node = (node as any).parentNode;
+      if (node) {
+        if (this._acceptNode(node) === NodeFilter.FILTER_ACCEPT) {
+          this._currentNode = node;
+          return node;
+        }
+      }
+    }
+    return null;
+  }
+
+  /**
+   * Move to the next node in document order
+   */
+  nextNode(): Node | null {
+    let node = this._currentNode;
+    let result = NodeFilter.FILTER_ACCEPT;
+
+    while (true) {
+      if (result !== NodeFilter.FILTER_REJECT) {
+        const firstChild = (node as any).firstChild;
+        if (firstChild) {
+          node = firstChild;
+          result = this._acceptNode(node);
+          if (result === NodeFilter.FILTER_ACCEPT) {
+            this._currentNode = node;
+            return node;
+          }
+          continue;
+        }
+      }
+
+      while (node) {
+        if (node === this._root) return null;
+        const nextSibling = (node as any).nextSibling;
+        if (nextSibling) {
+          node = nextSibling;
+          break;
+        }
+        node = (node as any).parentNode;
+      }
+
+      if (!node) return null;
+
+      result = this._acceptNode(node);
+      if (result === NodeFilter.FILTER_ACCEPT) {
+        this._currentNode = node;
+        return node;
+      }
+    }
+  }
+
+  /**
+   * Check node acceptance
+   */
+  private _acceptNode(node: Node): number {
+    const nodeTypeMask = 1 << (node.nodeType - 1);
+    if (!(this._whatToShow & nodeTypeMask)) {
+      return NodeFilter.FILTER_SKIP;
+    }
+
+    if (this._filter) {
+      if (typeof this._filter === 'function') {
+        return (this._filter as any)(node);
+      }
+      return this._filter.acceptNode(node);
+    }
+
+    return NodeFilter.FILTER_ACCEPT;
+  }
+}

package/src/node/collection/{HTMLCollection.ts → HTMLCollectionImp.ts}

@@ -1,11 +1,11 @@
-import { Element } from '../elements/Element';
+// 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 {
+export class HTMLCollectionImp implements HTMLCollection {
     // 인덱스 시그니처 선언
     [index: number]: Element;
     
@@ -83,6 +83,7 @@ export class HTMLCollection {
     /**
      * Returns an iterator for the collection.
      */
+    // @ts-ignore
     [Symbol.iterator](): IterableIterator<Element> {
         return this._elements[Symbol.iterator]();
     }

package/src/node/collection/HTMLCollectionOfImp.ts

@@ -0,0 +1,12 @@
+// import { Element } from '../elements/Element';
+import { HTMLCollectionImp } from './HTMLCollectionImp';
+
+/**
+ * **`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 HTMLCollectionOfImp<T extends Element> extends HTMLCollectionImp implements HTMLCollectionOfImp<T>{
+
+
+}

package/src/node/collection/NodeList.ts

@@ -1,4 +1,4 @@
-import { Node } from '../Node';
+// import { Node } from '../Node';
 
 /**
  * **`NodeList`** objects are collections of nodes, usually returned by properties such as Node.childNodes and methods such as document.querySelectorAll().