@dooboostore/dom-parser 1.0.0

package/src/node/DocumentBase.ts

@@ -0,0 +1,465 @@
+import {ParentNodeBase} from './ParentNodeBase';
+import {DOCUMENT_NODE, Node} from './Node';
+import {Document, ElementCreationOptions, DocumentReadyState, DocumentVisibilityState, ImportNodeOptions, CaretPositionFromPointOptions, StartViewTransitionOptions, ViewTransitionUpdateCallback} from './Document';
+import {Comment} from './Comment';
+import {Text} from './Text';
+import {DocumentFragment} from './DocumentFragment';
+import {DocumentFragmentBase} from './DocumentFragmentBase';
+import {Element} from './elements/Element';
+import {HTMLElement} from './elements/HTMLElement';
+import {HTMLCollection, HTMLCollectionOf} from './collection';
+import {HTMLElementTagNameMap, SVGElementTagNameMap, MathMLElementTagNameMap, HTMLElementDeprecatedTagNameMap} from './elements';
+import {NodeListOf} from './collection/NodeListOf';
+import {ElementFactory} from '../factory';
+import {NodeIterator, NodeFilter} from './NodeIterator';
+
+// Document event listener interface
+interface DocumentEventListener {
+    type: string;
+    listener: (event: any) => void;
+    options?: boolean | AddEventListenerOptions;
+}
+
+/**
+ * The **`DocumentBase`** class is the concrete implementation of the Document interface.
+ */
+export class DocumentBase extends ParentNodeBase implements Document {
+    // Event system
+    private _eventListeners: DocumentEventListener[] = [];
+    private _readyState: DocumentReadyState = 'uninitialized' as any;
+    private _window: any = null; // Reference to window for load event
+    // Properties
+    readonly URL: string = 'about:blank';
+    alinkColor: string = '';
+    readonly all: any = null;
+    readonly anchors: HTMLCollectionOf<any> = new HTMLCollectionOf([]);
+    readonly applets: HTMLCollection = new HTMLCollection([]);
+    bgColor: string = '';
+    body: HTMLElement = null as any;
+    readonly characterSet: string = 'UTF-8';
+    readonly charset: string = 'UTF-8';
+    readonly compatMode: string = 'CSS1Compat';
+    readonly contentType: string = 'text/html';
+    cookie: string = '';
+    readonly currentScript: any = null;
+    readonly defaultView: any = null;
+    designMode: string = 'off';
+    dir: string = '';
+    readonly doctype: any = null;
+    readonly documentElement: HTMLElement = null as any;
+    readonly documentURI: string = 'about:blank';
+    domain: string = '';
+    readonly embeds: HTMLCollectionOf<any> = new HTMLCollectionOf([]);
+    fgColor: string = '';
+    readonly forms: HTMLCollectionOf<any> = new HTMLCollectionOf([]);
+    readonly fragmentDirective: any = null;
+    readonly fullscreen: boolean = false;
+    readonly fullscreenEnabled: boolean = false;
+    readonly head: any = null;
+    readonly hidden: boolean = false;
+    readonly images: HTMLCollectionOf<any> = new HTMLCollectionOf([]);
+    readonly implementation: any = null;
+    readonly inputEncoding: string = 'UTF-8';
+    readonly lastModified: string = new Date().toString();
+    linkColor: string = '';
+    readonly links: HTMLCollectionOf<any> = new HTMLCollectionOf([]);
+    
+    // Location property - simple implementation for Document
+    private _location: any = {
+        href: 'about:blank',
+        protocol: 'about:',
+        host: '',
+        hostname: '',
+        port: '',
+        pathname: 'blank',
+        search: '',
+        hash: '',
+        origin: 'null',
+        assign: (url: string) => { this._location.href = url; },
+        replace: (url: string) => { this._location.href = url; },
+        reload: () => {},
+        toString: () => this._location.href
+    };
+    
+    get location(): any {
+        return this._location;
+    }
+    
+    set location(href: string) {
+        this._location.href = href;
+        // Simple URL parsing for document location
+        try {
+            const url = new URL(href);
+            this._location.protocol = url.protocol;
+            this._location.host = url.host;
+            this._location.hostname = url.hostname;
+            this._location.port = url.port;
+            this._location.pathname = url.pathname;
+            this._location.search = url.search;
+            this._location.hash = url.hash;
+            this._location.origin = url.origin;
+        } catch (e) {
+            // Keep defaults for invalid URLs
+        }
+    }
+    
+    // Event handlers
+    onfullscreenchange: ((this: Document, ev: Event) => any) | null = null;
+    onfullscreenerror: ((this: Document, ev: Event) => any) | null = null;
+    onpointerlockchange: ((this: Document, ev: Event) => any) | null = null;
+    onpointerlockerror: ((this: Document, ev: Event) => any) | null = null;
+    onreadystatechange: ((this: Document, ev: Event) => any) | null = null;
+    onvisibilitychange: ((this: Document, ev: Event) => any) | null = null;
+    
+    get ownerDocument(): null {
+        return null;
+    }
+    readonly pictureInPictureEnabled: boolean = false;
+    readonly plugins: HTMLCollectionOf<any> = new HTMLCollectionOf([]);
+    get readyState(): DocumentReadyState {
+        return this._readyState;
+    }
+    readonly referrer: string = '';
+    readonly rootElement: any = null;
+    readonly scripts: HTMLCollectionOf<any> = new HTMLCollectionOf([]);
+    readonly scrollingElement: Element | null = null;
+    readonly timeline: any = null;
+    get title(): string {
+        const titleElement = this.querySelector('title');
+        return titleElement ? titleElement.textContent || '' : '';
+    }
+    
+    set title(value: string) {
+        let titleElement = this.querySelector('title');
+        if (!titleElement) {
+            // Create title element if it doesn't exist
+            titleElement = this.createElement('title');
+            const head = this.head || this.querySelector('head');
+            if (head) {
+                head.appendChild(titleElement);
+            }
+        }
+        titleElement.textContent = value;
+    }
+    readonly visibilityState: DocumentVisibilityState = 'visible';
+    vlinkColor: string = '';
+
+    constructor() {
+        super(DOCUMENT_NODE, '#document');
+        this._ownerDocument = null;
+
+        // Create basic document structure
+        const documentElement = this.createElement('html') as HTMLElement;
+        const head = this.createElement('head') as HTMLElement;
+        const body = this.createElement('body') as HTMLElement;
+
+        documentElement.appendChild(head);
+        documentElement.appendChild(body);
+        this.appendChild(documentElement);
+
+        // Set readonly properties
+        (this as any).documentElement = documentElement;
+        (this as any).head = head;
+        this.body = body;
+    }
+
+    get textContent(): null {
+        return null;
+    }
+
+    // Methods
+    adoptNode<T extends Node>(node: T): T {
+        (node as any)._ownerDocument = this;
+        return node;
+    }
+
+    captureEvents(): void {}
+
+    caretPositionFromPoint(_x: number, _y: number, _options?: CaretPositionFromPointOptions): any {
+        return null;
+    }
+
+    caretRangeFromPoint(_x: number, _y: number): any {
+        return null;
+    }
+
+    clear(): void {}
+
+    close(): void {}
+
+    createAttribute(localName: string): any {
+        return { name: localName, value: '' };
+    }
+
+    createAttributeNS(_namespace: string | null, qualifiedName: string): any {
+        return { name: qualifiedName, value: '' };
+    }
+
+    createCDATASection(data: string): any {
+        return { data, nodeType: 4 };
+    }
+
+    createComment(data: string): Comment {
+        return new Comment(data, this);
+    }
+
+    createDocumentFragment(): DocumentFragment {
+        return new DocumentFragmentBase(this);
+    }
+
+    createElement<K extends keyof HTMLElementTagNameMap>(tagName: K, _options?: ElementCreationOptions): HTMLElementTagNameMap[K];
+    createElement<K extends keyof HTMLElementDeprecatedTagNameMap>(tagName: K, _options?: ElementCreationOptions): HTMLElementDeprecatedTagNameMap[K];
+    createElement(tagName: string, _options?: ElementCreationOptions): HTMLElement;
+    createElement(tagName: string, _options?: ElementCreationOptions): HTMLElement {
+        return ElementFactory.createElement(tagName, this);
+    }
+
+    createElementNS(namespaceURI: "http://www.w3.org/1999/xhtml", qualifiedName: string): HTMLElement;
+    createElementNS<K extends keyof SVGElementTagNameMap>(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: K): SVGElementTagNameMap[K];
+    createElementNS(namespaceURI: "http://www.w3.org/2000/svg", qualifiedName: string): any;
+    createElementNS<K extends keyof MathMLElementTagNameMap>(namespaceURI: "http://www.w3.org/1998/Math/MathML", qualifiedName: K): MathMLElementTagNameMap[K];
+    createElementNS(namespaceURI: "http://www.w3.org/1998/Math/MathML", qualifiedName: string): any;
+    createElementNS(namespaceURI: string | null, qualifiedName: string, options?: ElementCreationOptions): Element;
+    createElementNS(_namespace: string | null, qualifiedName: string, _options?: string | ElementCreationOptions): Element;
+    createElementNS(_namespaceURI: string | null, qualifiedName: string, _options?: ElementCreationOptions | string): Element {
+        return ElementFactory.createElement(qualifiedName, this);
+    }
+
+    createEvent(_eventInterface: string): any {
+        return {};
+    }
+
+    createNodeIterator(root: Node, whatToShow: number = NodeFilter.SHOW_ALL, filter: NodeFilter | null = null): NodeIterator {
+        return new NodeIterator(root, whatToShow, filter);
+    }
+
+    createProcessingInstruction(target: string, data: string): any {
+        return { target, data, nodeType: 7 };
+    }
+
+    createRange(): any {
+        return {};
+    }
+
+    createTextNode(data: string): Text {
+        const { TextBase } = require('./TextBase');
+        return new TextBase(data, this);
+    }
+
+    createTreeWalker(_root: Node, _whatToShow?: number, _filter?: any): any {
+        return {};
+    }
+
+    execCommand(_commandId: string, _showUI?: boolean, _value?: string): boolean {
+        return false;
+    }
+
+    exitFullscreen(): Promise<void> {
+        return Promise.resolve();
+    }
+
+    exitPictureInPicture(): Promise<void> {
+        return Promise.resolve();
+    }
+
+    exitPointerLock(): void {}
+
+    getElementById(elementId: string): HTMLElement | null {
+        const elements = this.querySelectorAll(`#${elementId}`);
+        return elements.length > 0 ? elements[0] as HTMLElement : null;
+    }
+
+    getElementsByClassName(classNames: string): HTMLCollectionOf<Element> {
+        const elements = this.querySelectorAll(`.${classNames.split(' ').join('.')}`);
+        return new HTMLCollectionOf(Array.from(elements));
+    }
+
+    getElementsByName(elementName: string): NodeListOf<HTMLElement> {
+        const elements = this.querySelectorAll(`[name="${elementName}"]`);
+        return new NodeListOf(Array.from(elements) as HTMLElement[]);
+    }
+
+    getElementsByTagName<K extends keyof HTMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementTagNameMap[K]>;
+    getElementsByTagName<K extends keyof SVGElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<SVGElementTagNameMap[K]>;
+    getElementsByTagName<K extends keyof MathMLElementTagNameMap>(qualifiedName: K): HTMLCollectionOf<MathMLElementTagNameMap[K]>;
+    getElementsByTagName<K extends keyof HTMLElementDeprecatedTagNameMap>(qualifiedName: K): HTMLCollectionOf<HTMLElementDeprecatedTagNameMap[K]>;
+    getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
+    getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element> {
+        const elements = this.querySelectorAll<Element>(qualifiedName);
+        return new HTMLCollectionOf(Array.from(elements));
+    }
+
+    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1999/xhtml", localName: string): HTMLCollectionOf<HTMLElement>;
+    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/2000/svg", localName: string): HTMLCollectionOf<any>;
+    getElementsByTagNameNS(namespaceURI: "http://www.w3.org/1998/Math/MathML", localName: string): HTMLCollectionOf<any>;
+    getElementsByTagNameNS(_namespace: string | null, localName: string): HTMLCollectionOf<Element>;
+    getElementsByTagNameNS(_namespace: string | null, localName: string): HTMLCollectionOf<Element> {
+        return this.getElementsByTagName(localName);
+    }
+
+    getSelection(): any {
+        return null;
+    }
+
+    hasFocus(): boolean {
+        return false;
+    }
+
+    hasStorageAccess(): Promise<boolean> {
+        return Promise.resolve(false);
+    }
+
+    importNode<T extends Node>(node: T, _options?: boolean | ImportNodeOptions): T {
+        const cloned = (node as any).cloneNode(typeof _options === 'boolean' ? _options : _options?.deep);
+        (cloned as any)._ownerDocument = this;
+        return cloned;
+    }
+
+    open(_unused1?: string, _unused2?: string): Document;
+    open(_url: string | URL, _name: string, _features: string): any;
+    open(_arg1?: string | URL, _arg2?: string, _arg3?: string): Document | any {
+        if (arguments.length <= 2) {
+            return this;
+        }
+        return null;
+    }
+
+    queryCommandEnabled(_commandId: string): boolean {
+        return false;
+    }
+
+    queryCommandIndeterm(_commandId: string): boolean {
+        return false;
+    }
+
+    queryCommandState(_commandId: string): boolean {
+        return false;
+    }
+
+    queryCommandSupported(_commandId: string): boolean {
+        return false;
+    }
+
+    queryCommandValue(_commandId: string): string {
+        return '';
+    }
+
+    releaseEvents(): void {}
+
+    requestStorageAccess(): Promise<void> {
+        return Promise.resolve();
+    }
+
+    startViewTransition(_callbackOptions?: ViewTransitionUpdateCallback | StartViewTransitionOptions): any {
+        return {};
+    }
+
+    write(...text: string[]): void {
+        console.log('Document.write:', text.join(''));
+    }
+
+    writeln(...text: string[]): void {
+        this.write(...text, '\n');
+    }
+
+    addEventListener(type: string, listener: any, options?: boolean | any): void {
+        // Support DOMContentLoaded and readystatechange events
+        if (type === 'DOMContentLoaded' || type === 'readystatechange') {
+            this._eventListeners.push({
+                type,
+                listener: typeof listener === 'function' ? listener : listener.handleEvent,
+                options
+            });
+        }
+    }
+
+    removeEventListener(type: string, listener: any, options?: boolean | any): void {
+        if (type === 'DOMContentLoaded' || type === 'readystatechange') {
+            const targetListener = typeof listener === 'function' ? listener : listener.handleEvent;
+            this._eventListeners = this._eventListeners.filter(
+                eventListener => !(eventListener.type === type && eventListener.listener === targetListener)
+            );
+        }
+    }
+
+    dispatchEvent(event: any): boolean {
+        const eventListeners = this._eventListeners.filter(listener => listener.type === event.type);
+        
+        for (const eventListener of eventListeners) {
+            try {
+                eventListener.listener.call(this, event);
+                
+                // Handle 'once' option
+                if (eventListener.options && typeof eventListener.options === 'object' && eventListener.options.once) {
+                    this.removeEventListener(event.type, eventListener.listener);
+                }
+            } catch (error) {
+                console.error('Error in document event listener:', error);
+            }
+        }
+        
+        return true;
+    }
+
+    /**
+     * Set window reference for load event dispatching
+     */
+    setWindow(window: any): void {
+        this._window = window;
+    }
+
+    /**
+     * Change document ready state and dispatch events
+     */
+    setReadyState(state: DocumentReadyState): void {
+        if (this._readyState === state) return;
+        
+        this._readyState = state;
+        
+        // Dispatch readystatechange event
+        this.dispatchEvent({
+            type: 'readystatechange',
+            target: this,
+            readyState: state
+        });
+        
+        // Dispatch DOMContentLoaded when interactive
+        if (state === 'interactive') {
+            this.dispatchEvent({
+                type: 'DOMContentLoaded',
+                target: this
+            });
+        }
+        
+        // Dispatch load event on window when complete
+        if (state === 'complete' && this._window) {
+            // Use setTimeout to ensure it's dispatched after current execution
+            setTimeout(() => {
+                if (this._window && this._window.dispatchEvent) {
+                    this._window.dispatchEvent({
+                        type: 'load',
+                        target: this._window
+                    });
+                }
+            }, 0);
+        }
+    }
+
+    /**
+     * Simulate document loading process
+     */
+    simulateLoading(): void {
+        // Start with loading state
+        this.setReadyState('loading');
+        
+        // Simulate DOM parsing completion
+        setTimeout(() => {
+            this.setReadyState('interactive');
+            
+            // Simulate resource loading completion
+            setTimeout(() => {
+                this.setReadyState('complete');
+            }, 10);
+        }, 5);
+    }
+}

package/src/node/DocumentFragment.ts

@@ -0,0 +1,44 @@
+import { Node } from './Node';
+import { ParentNode } from './ParentNode';
+
+/**
+ * The **`DocumentFragment`** interface represents a minimal document object that has no parent.
+ * It is used as a lightweight version of Document that stores a segment of a document structure comprised of nodes just like a standard document.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/DocumentFragment)
+ */
+export interface DocumentFragment extends Node, ParentNode {
+    /**
+     * Returns the number of child elements of this DocumentFragment.
+     */
+    readonly childElementCount: number;
+
+    /**
+     * Returns the first Element node within the DocumentFragment, in document order, that matches the specified selectors.
+     */
+    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;
+    querySelector<E extends Element = Element>(selectors: string): E | null;
+    querySelector(selectors: string): Element | null;
+
+    /**
+     * Returns all Element nodes within the DocumentFragment that match the specified selectors.
+     */
+    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]>;
+    querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
+    querySelectorAll(selectors: string): NodeListOf<Element>;
+
+    /**
+     * Returns the Element within the DocumentFragment that has the specified ID.
+     */
+    getElementById(elementId: string): HTMLElement | null;
+}
+
+// Import types for the interface
+import { HTMLElementTagNameMap, SVGElementTagNameMap, MathMLElementTagNameMap } from './elements';
+import { Element } from './elements/Element';
+import { HTMLElement } from './elements/HTMLElement';
+import { NodeListOf } from './collection/NodeListOf';

package/src/node/DocumentFragmentBase.ts

@@ -0,0 +1,109 @@
+import { ParentNodeBase } from './ParentNodeBase';
+import { DocumentFragment } from './DocumentFragment';
+import { Document } from './Document';
+import {DOCUMENT_FRAGMENT_NODE, ELEMENT_NODE, Node} from './Node';
+import { NodeBase } from './NodeBase';
+import { Element } from './elements/Element';
+import { HTMLElement } from './elements/HTMLElement';
+import { HTMLElementTagNameMap, SVGElementTagNameMap, MathMLElementTagNameMap } from './elements';
+import { NodeListOf } from './collection/NodeListOf';
+
+/**
+ * The **`DocumentFragmentBase`** class is the concrete implementation of the DocumentFragment interface.
+ * 
+ * DocumentFragment is a minimal document object that has no parent. It is used as a lightweight version of Document
+ * that stores a segment of a document structure comprised of nodes just like a standard document.
+ */
+export class DocumentFragmentBase extends ParentNodeBase implements DocumentFragment {
+    constructor(ownerDocument?: Document) {
+        super(DOCUMENT_FRAGMENT_NODE, '#document-fragment', ownerDocument); // DOCUMENT_FRAGMENT_NODE = 11
+    }
+
+    /**
+     * Returns the number of child elements of this DocumentFragment.
+     */
+    get childElementCount(): number {
+        let count = 0;
+        for (const child of this._childNodesInternal) {
+            if (child && child.nodeType === ELEMENT_NODE) { // ELEMENT_NODE
+                count++;
+            }
+        }
+        return count;
+    }
+
+    /**
+     * Returns the first Element node within the DocumentFragment that matches the specified selectors.
+     */
+    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;
+    querySelector<E extends Element = Element>(selectors: string): E | null;
+    querySelector(selectors: string): Element | null;
+    querySelector(selectors: string): Element | null {
+        const elements = this.querySelectorAll(selectors);
+        return elements.length > 0 ? elements.item(0) : null;
+    }
+
+    /**
+     * Returns all Element nodes within the DocumentFragment that match the specified selectors.
+     */
+    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]>;
+    querySelectorAll<E extends Element = Element>(selectors: string): NodeListOf<E>;
+    querySelectorAll(selectors: string): NodeListOf<Element>;
+    querySelectorAll(selectors: string): NodeListOf<Element> {
+        // Use the inherited querySelectorAll from ParentNodeBase
+        return super.querySelectorAll(selectors);
+    }
+
+    /**
+     * Returns the Element within the DocumentFragment that has the specified ID.
+     */
+    getElementById(elementId: string): HTMLElement | null {
+        const element = this.querySelector(`#${elementId}`);
+        return element as HTMLElement | null;
+    }
+
+    /**
+     * Override cloneNode to return DocumentFragment
+     */
+    cloneNode(deep?: boolean): DocumentFragmentBase {
+        const clone = new DocumentFragmentBase(this._ownerDocument as Document);
+        
+        if (deep) {
+            for (const child of this._childNodesInternal) {
+                if (child && 'cloneNode' in child) {
+                    clone.appendChild((child as any).cloneNode(true));
+                }
+            }
+        }
+        
+        return clone;
+    }
+
+    /**
+     * Override appendChild to handle DocumentFragment behavior
+     * When a DocumentFragment is appended to another node, its children are moved, not the fragment itself
+     */
+    appendChild<T extends Node>(node: T): T {
+        // If the node being appended is a DocumentFragment, move its children instead
+        if (node.nodeType === DOCUMENT_FRAGMENT_NODE) {
+            const fragment = node as any;
+            
+            // Move all children from fragment to this node
+            while (fragment._childNodesInternal && fragment._childNodesInternal.length > 0) {
+                const child = fragment._childNodesInternal[0];
+                if (child) {
+                    fragment.removeChild(child);
+                    super.appendChild(child);
+                }
+            }
+            
+            return node;
+        }
+        
+        return super.appendChild(node);
+    }
+}

package/src/node/GetRootNodeOptions.ts

@@ -0,0 +1,13 @@
+/**
+ * Options for the getRootNode() method.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/Node/getRootNode)
+ */
+export interface GetRootNodeOptions {
+    /**
+     * A boolean value that indicates whether the shadow root, if any, should be returned.
+     * If set to false (default), a shadow root node is not returned.
+     * If set to true, a shadow root node is returned.
+     */
+    composed?: boolean;
+}