@dooboostore/dom-parser 1.0.0

package/src/index.ts

@@ -0,0 +1,28 @@
+import { DomParser, DomParserOptions } from "./DomParser";
+
+// Main exports - what users actually need
+export { DomParser };
+
+// Utility function to parse HTML and return window object
+export const parseHTML = (html: string, option?: DomParserOptions) => {
+    const parser = new DomParser(html, option);
+    return parser.window;
+}
+
+// Default export
+export default {
+    DomParser,
+    parseHTML
+}
+
+// Internal exports (commented out - users don't need these)
+// export { WindowBase } from './window/WindowBase';
+// export { Window } from './window/Window';
+// export { Document } from "./node/Document";
+// export { NodeIterator, NodeFilter } from "./node/NodeIterator";
+// export * from "./factory";
+// export * from "./node/elements";
+// export { DocumentBase } from "./node/DocumentBase";
+// export * from "./node/DocumentFragment";
+// export { DocumentFragmentBase } from "./node/DocumentFragmentBase";
+// export * from "./node/Node";

package/src/node/CharacterData.ts

@@ -0,0 +1,58 @@
+import { Node } from './Node';
+import { ChildNode } from './ChildNode';
+
+/**
+ * The **`CharacterData`** abstract interface represents a Node object that contains characters.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData)
+ */
+export interface CharacterData extends Node, ChildNode {
+    /**
+     * The **`CharacterData.data`** property represents the textual data contained in this object.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/data)
+     */
+    data: string;
+    
+    /**
+     * The **`CharacterData.length`** read-only property returns the number of characters in the contained data.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/length)
+     */
+    readonly length: number;
+    
+    /**
+     * The **`CharacterData.appendData()`** method appends the given string to the CharacterData.data string.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/appendData)
+     */
+    appendData(data: string): void;
+    
+    /**
+     * The **`CharacterData.deleteData()`** method removes the specified amount of characters.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/deleteData)
+     */
+    deleteData(offset: number, count: number): void;
+    
+    /**
+     * The **`CharacterData.insertData()`** method inserts the provided data into this CharacterData node's current data.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/insertData)
+     */
+    insertData(offset: number, data: string): void;
+    
+    /**
+     * The **`CharacterData.replaceData()`** method replaces a portion of the existing data with the specified data.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/replaceData)
+     */
+    replaceData(offset: number, count: number, data: string): void;
+    
+    /**
+     * The **`CharacterData.substringData()`** method returns a portion of the existing data.
+     * 
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/substringData)
+     */
+    substringData(offset: number, count: number): string;
+}

package/src/node/ChildNode.ts

@@ -0,0 +1,42 @@
+import { Node } from './Node';
+
+/**
+ * The **`ChildNode`** interface contains methods and properties that are common to all types of Node objects that can have a parent.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/ChildNode)
+ */
+export interface ChildNode extends Node {
+    /**
+     * Inserts nodes just after 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/CharacterData/after)
+     */
+    after(...nodes: (Node | string)[]): void;
+
+    /**
+     * Inserts nodes just before 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/CharacterData/before)
+     */
+    before(...nodes: (Node | string)[]): void;
+
+    /**
+     * Removes node.
+     *
+     * [MDN Reference](https://developer.mozilla.org/docs/Web/API/CharacterData/remove)
+     */
+    remove(): void;
+
+    /**
+     * Replaces 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/CharacterData/replaceWith)
+     */
+    replaceWith(...nodes: (Node | string)[]): void;
+}

package/src/node/ChildNodeBase.ts

@@ -0,0 +1,54 @@
+import { NodeBase } from './NodeBase';
+import { ChildNode } from './ChildNode';
+// import {Text} from "./Text";
+
+/**
+ * Base implementation of the ChildNode interface
+ */
+export abstract class ChildNodeBase extends NodeBase implements ChildNode {
+    
+    // ChildNode interface implementation
+    after(...nodes: (NodeBase | string)[]): void {
+        if (!this.parentNode) return;
+        
+        const nextSibling = this.nextSibling;
+        for (const node of nodes) {
+            if (typeof node === 'string') {
+                const { TextBase } = require('./TextBase');
+                const textNode = new TextBase(node, this._ownerDocument);
+                this.parentNode.insertBefore(textNode, nextSibling);
+            } else {
+                this.parentNode.insertBefore(node, nextSibling);
+            }
+        }
+    }
+
+    before(...nodes: (NodeBase | string)[]): void {
+        if (!this.parentNode) return;
+        
+        for (const node of nodes) {
+            if (typeof node === 'string') {
+                const { TextBase } = require('./TextBase');
+                const textNode = new TextBase(node, this._ownerDocument);
+                this.parentNode.insertBefore(textNode, this);
+            } else {
+                this.parentNode.insertBefore(node, this);
+            }
+        }
+    }
+
+    remove(): void {
+        if (this.parentNode) {
+            this.parentNode.removeChild(this);
+        }
+    }
+
+    replaceWith(...nodes: (NodeBase | string)[]): void {
+        if (!this.parentNode) return;
+        
+        this.before(...nodes);
+        this.remove();
+    }
+}
+
+// TextNode is now in a separate file

package/src/node/Comment.ts

@@ -0,0 +1,98 @@
+import { ChildNodeBase } from './ChildNodeBase';
+import { COMMENT_NODE } from './Node';
+
+/**
+ * The **`Comment`** interface represents textual notations within markup; although it is generally not visually shown, such comments are available to be read in the source view.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Comment)
+ */
+// export interface Comment {
+//     readonly nodeType: typeof COMMENT_NODE;
+//     readonly nodeName: '#comment';
+//     data: string;
+//     readonly length: number;
+//     appendData(data: string): void;
+//     deleteData(offset: number, count: number): void;
+//     insertData(offset: number, data: string): void;
+//     replaceData(offset: number, count: number, data: string): void;
+//     substringData(offset: number, count: number): string;
+// }
+
+/**
+ * The **`CommentNode`** class represents a comment node in the DOM.
+ */
+export class Comment extends ChildNodeBase  {
+    private _data: string;
+
+    constructor(data: string, ownerDocument?: any) {
+        super(COMMENT_NODE, '#comment', 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 {
+        return this._data;
+    }
+
+    set textContent(value: string | null) {
+        this._data = value || '';
+        this._nodeValue = 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);
+    }
+
+    cloneNode(deep?: boolean): Comment {
+        return new Comment(this._data, this._ownerDocument);
+    }
+
+    toString(): string {
+        return `<!--${this._data}-->`;
+    }
+}