npm - @dooboostore/dom-parser - Versions diffs - 1.0.2 → 1.0.4 - Mend

@dooboostore/dom-parser 1.0.2 → 1.0.4

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (727) hide show

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@dooboostore/dom-parser",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "license": "MIT",
   "type": "module",
   "sideEffects": false,
@@ -50,6 +50,11 @@
       "import": "./dist/esm/index.js",
       "require": "./dist/cjs/index.js"
     },
+    "./bundle-entry": {
+      "types": "./dist/types/bundle-entry.d.ts",
+      "import": "./dist/esm/bundle-entry.js",
+      "require": "./dist/cjs/bundle-entry.js"
+    },
     "./cjs": {
       "types": "./dist/types/index.d.ts",
       "require": "./dist/cjs/index.js"

package/src/DomParser.ts CHANGED Viewed

@@ -1,7 +1,17 @@
-import {DocumentBase} from './node/DocumentBase';
-import {TextBase} from './node/TextBase';
-import {Comment} from './node/Comment';
-import {WindowBase} from './window/WindowBase';
+import { DocumentBase } from './node/DocumentBase';
+import { TextBase } from './node/TextBase';
+import { Comment } from './node/Comment';
+import { WindowBase } from './window/WindowBase';
+import { ElementBase } from './node/elements/ElementBase';
+import { ElementFactory } from './factory/ElementFactory';
+// Inject dependencies into ElementBase to break circular references
+// without using 'require' or 'global' injection magic.
+ElementBase.dependencies = {
+  ElementFactory,
+  TextBase,
+  Comment
+};
 export interface DomParserOptions {
   href?: string;
@@ -12,8 +22,9 @@ export class DomParser {
   private _document: Document | null;
   constructor(html: string, option?: DomParserOptions) {
+    console.log('create DomParser==',html)
     // Create WindowBase instance with the document
-    const windowBase = new WindowBase({initialUrl: option?.href});
+    const windowBase = new WindowBase({ initialUrl: option?.href });
     this._window = windowBase as unknown as Window;
     this._document = windowBase.document as any;
@@ -51,7 +62,7 @@ export class DomParser {
       this._window.close();
       this._window = null;
     }
     this._document = null;
   }
@@ -62,7 +73,7 @@ export class DomParser {
     if (!this._document) {
       throw new Error('DomParser has been destroyed');
     }
     // Clear current document content
     this.clearDocument();
@@ -75,7 +86,7 @@ export class DomParser {
   private clearDocument(): void {
     if (!this._document) return;
     // Clear document body and head content while preserving structure
     if (this._document.head) {
       while (this._document.head.firstChild) {
@@ -94,13 +105,18 @@ export class DomParser {
     if (!this._document) {
       throw new Error('DomParser has been destroyed');
     }
-    // Simple HTML parsing implementation
+    // Ensure basic HTML structure if input is empty or lacks it
     if (!html.trim()) {
-      return;
+      html = '<html><head></head><body></body></html>';
+    } else if (!/<html/i.test(html)) {
+      // If it's just a fragment, we still need html/head/body for a full document
+      // but only if it's not explicitly intended to be a fragment?
+      // Actually, standard DOMParser.parseFromString always creates them.
+      html = `<html><head></head><body>${html}</body></html>`;
     }
     // Basic HTML parsing - this is a simplified version
-    // In a real implementation, you'd use a proper HTML parser
     this.parseHTMLString(html, this.document);
   }
@@ -204,11 +220,9 @@ export class DomParser {
         attributes = attributes.slice(0, -1).trim();
       }
       // Create element
       const element = this.document.createElement(tagName.toLowerCase());
       // Parse attributes
       if (attributes.trim()) {
         this.parseAttributes(attributes, element);
@@ -372,7 +386,7 @@ export class DomParser {
       '&rdquo;': '"'
     };
-    return str.replace(/&[a-zA-Z0-9#]+;/g, (entity) => {
+    return str.replace(/&[a-zA-Z0-9#]+;/g, entity => {
       // Handle named entities
       if (entityMap[entity]) {
         return entityMap[entity];
@@ -468,7 +482,6 @@ export class DomParser {
     // Choose the BODY element with content, then attributes, then first one
     let bodyElement = null;
     // First priority: BODY with child nodes (content)
     for (let i = 0; i < allBodyElements.length; i++) {
       const body = allBodyElements[i];
@@ -494,10 +507,6 @@ export class DomParser {
       bodyElement = allBodyElements[0];
     }
-    // For now, just use the elements as they are parsed
-    // TODO: Implement proper DOM structure reorganization later
     // Set document references
     if (htmlElement) {
       (this.document as any).documentElement = htmlElement;
@@ -509,4 +518,4 @@ export class DomParser {
       (this.document as any).body = bodyElement;
     }
   }
-}
+}

package/src/bundle-entry.ts ADDED Viewed

	@@ -0,0 +1,2 @@
1	+ export * from './index';
2	+ export * as DomParserModule from './index';

package/src/factory/ElementFactory.ts CHANGED Viewed

@@ -1,69 +1,102 @@
-import { HTMLElementBase, HTMLGenericElement, htmlElements, svgElements, mathmlElements } from '../node/elements';
+import {HTMLElementBase, htmlElements, svgElements, mathmlElements, HTMLElement} from '../node/elements';
 /**
  * Factory for creating HTML elements based on tag names
  */
 export class ElementFactory {
-    /**
-     * Creates an HTML element based on the tag name
-     */
-    static createElement(tagName: string, ownerDocument?: any): HTMLElementBase {
-        const normalizedTagName = tagName.toLowerCase();
-        // Check HTML elements
-        for (const [tag, ElementClass] of Object.entries(htmlElements)) {
-            if (tag === normalizedTagName) {
-                return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
-            }
-        }
-        // Check SVG elements
-        for (const [tag, ElementClass] of Object.entries(svgElements)) {
-            if (tag === normalizedTagName) {
-                return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
-            }
-        }
-        // Check MathML elements
-        for (const [tag, ElementClass] of Object.entries(mathmlElements)) {
-            if (tag === normalizedTagName) {
-                return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
-            }
+  /**
+   * Creates an HTML element based on the tag name
+   */
+  static createElement(tagName: string, ownerDocument?: any, options?: any): HTMLElementBase {
+    const normalizedTagName = tagName.toLowerCase();
+    const customElements = (ownerDocument as any)?.defaultView?.customElements;
+    // 1. Check for Customized Built-in Elements (is="")
+    const isAttribute = typeof options === 'string' ? options : options?.is;
+    if (isAttribute && customElements && typeof customElements.get === 'function') {
+      const CustomElementClass = customElements.get(isAttribute);
+      if (CustomElementClass) {
+        const element = new CustomElementClass() as any;
+        element._tagName = tagName.toUpperCase();
+        element.nodeName = tagName.toUpperCase();
+        element._ownerDocument = ownerDocument;
+        if (element.setAttribute) {
+          element.setAttribute('is', isAttribute);
         }
-        // For unknown elements, create a generic HTMLElement
-        return new HTMLGenericElement(tagName.toUpperCase(), ownerDocument);
+        return element;
+      }
     }
-    /**
-     * Get all supported HTML tag names
-     */
-    static getSupportedHTMLTagNames(): string[] {
-        return Object.keys(htmlElements);
+    // 2. Check for Autonomous Custom Elements (or preserve unknown custom tags)
+    //   console.log('vvv2222222vvvvvvvvv222222vvvvv', tagName, normalizedTagName)
+    if (normalizedTagName.includes('-')) {
+      // console.log('vvvvvvvvvvvvvvvvv')
+      if (customElements && typeof customElements.get === 'function') {
+        const CustomElementClass = customElements.get(normalizedTagName);
+        if (CustomElementClass) {
+          const element = new CustomElementClass() as any;
+          element._tagName = tagName.toUpperCase();
+          element.nodeName = tagName.toUpperCase();
+          element._ownerDocument = ownerDocument;
+          return element;
+        }
+      }
+      // No registered custom element yet – keep the tag name intact.
+      return new HTMLElement(tagName.toUpperCase(), ownerDocument);
     }
-    /**
-     * Get all supported SVG tag names
-     */
-    static getSupportedSVGTagNames(): string[] {
-        return Object.keys(svgElements);
+    // 3. Check HTML elements
+    for (const [tag, ElementClass] of Object.entries(htmlElements)) {
+      if (tag === normalizedTagName) {
+        return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
+      }
     }
-    /**
-     * Get all supported MathML tag names
-     */
-    static getSupportedMathMLTagNames(): string[] {
-        return Object.keys(mathmlElements);
+    // Check SVG elements
+    for (const [tag, ElementClass] of Object.entries(svgElements)) {
+      if (tag === normalizedTagName) {
+        return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
+      }
     }
-    /**
-     * Get all supported tag names
-     */
-    static getSupportedTagNames(): string[] {
-        return [
-            ...ElementFactory.getSupportedHTMLTagNames(),
-            ...ElementFactory.getSupportedSVGTagNames(),
-            ...ElementFactory.getSupportedMathMLTagNames()
-        ];
+    // Check MathML elements
+    for (const [tag, ElementClass] of Object.entries(mathmlElements)) {
+      if (tag === normalizedTagName) {
+        return new ElementClass(tagName.toUpperCase(), ownerDocument) as HTMLElementBase;
+      }
     }
-}
+    // For unknown elements, create a generic HTMLElement
+    return new HTMLElement(tagName.toUpperCase(), ownerDocument);
+  }
+  /**
+   * Get all supported HTML tag names
+   */
+  static getSupportedHTMLTagNames(): string[] {
+    return Object.keys(htmlElements);
+  }
+  /**
+   * Get all supported SVG tag names
+   */
+  static getSupportedSVGTagNames(): string[] {
+    return Object.keys(svgElements);
+  }
+  /**
+   * Get all supported MathML tag names
+   */
+  static getSupportedMathMLTagNames(): string[] {
+    return Object.keys(mathmlElements);
+  }
+  /**
+   * Get all supported tag names
+   */
+  static getSupportedTagNames(): string[] {
+    return [...ElementFactory.getSupportedHTMLTagNames(), ...ElementFactory.getSupportedSVGTagNames(), ...ElementFactory.getSupportedMathMLTagNames()];
+  }
+}

package/src/index.ts CHANGED Viewed

@@ -1,19 +1,31 @@
-import { DomParser, DomParserOptions } from "./DomParser";
+import {DomParser, DomParserOptions} from './DomParser';
 // Main exports - what users actually need
-export { DomParser };
+export {DomParser};
+export {NodeIterator} from './node/NodeIterator';
+export {NodeFilter} from './node/NodeFilter'
+export { HTMLElementBase } from './node/elements/HTMLElementBase';
+export { ElementBase } from './node/elements/ElementBase';
+export { HTMLElement } from './node/elements/HTMLElement';
+export { NodeBase } from './node/NodeBase';
+export { ParentNodeBase } from './node/ParentNodeBase';
+export { ChildNodeBase } from './node/ChildNodeBase';
+export { DocumentBase } from './node/DocumentBase';
+export { DocumentFragmentBase } from './node/DocumentFragmentBase';
+export { ShadowRootBase } from './node/ShadowRootBase';
+export { WindowBase } from './window/WindowBase';
+export { ElementFactory } from './factory/ElementFactory';
 // 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;
-}
+  const parser = new DomParser(html, option);
+  return parser.window;
+};
 // Default export
 export default {
-    DomParser,
-    parseHTML
-}
+  DomParser,
+  parseHTML
+};
 // Internal exports (commented out - users don't need these)
 // export { WindowBase } from './window/WindowBase';
@@ -25,4 +37,4 @@ export default {
 // export { DocumentBase } from "./node/DocumentBase";
 // export * from "./node/DocumentFragment";
 // export { DocumentFragmentBase } from "./node/DocumentFragmentBase";
-// export * from "./node/Node";
+// export * from "./node/Node";

package/src/node/CharacterData.ts CHANGED Viewed

@@ -1,5 +1,3 @@
-import { Node } from './Node';
-import { ChildNode } from './ChildNode';
 /**
  * The **`CharacterData`** abstract interface represents a Node object that contains characters.

package/src/node/ChildNode.ts CHANGED Viewed

@@ -1,42 +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;
-}
+// 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 CHANGED Viewed

@@ -1,54 +1,75 @@
+import { ELEMENT_NODE } from './Node';
 import { NodeBase } from './NodeBase';
-import { ChildNode } from './ChildNode';
-// import {Text} from "./Text";
 /**
  * Base implementation of the ChildNode interface
  */
+// @ts-ignore
 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);
-            }
-        }
+  get nextElementSibling(): Element | null {
+    let next = this.nextSibling;
+    while (next) {
+      if (next.nodeType === ELEMENT_NODE) return next as unknown as Element;
+      next = next.nextSibling;
     }
+    return null;
+  }
-    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);
-            }
-        }
+  get previousElementSibling(): Element | null {
+    let prev = this.previousSibling;
+    while (prev) {
+      if (prev.nodeType === ELEMENT_NODE) return prev as unknown as Element;
+      prev = prev.previousSibling;
     }
+    return null;
+  }
-    remove(): void {
-        if (this.parentNode) {
-            this.parentNode.removeChild(this);
-        }
+  get assignedSlot(): any | null {
+    return null;
+  }
+  // ChildNode interface implementation
+  after(...nodes: (Node | 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);
+      }
     }
+  }
-    replaceWith(...nodes: (NodeBase | string)[]): void {
-        if (!this.parentNode) return;
-        this.before(...nodes);
-        this.remove();
+  before(...nodes: (Node | 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 as unknown as Node);
+      } else {
+        this.parentNode.insertBefore(node, this as unknown as Node);
+      }
     }
+  }
+  remove(): void {
+    if (this.parentNode) {
+      this.parentNode.removeChild(this as unknown as Node);
+    }
+  }
+  replaceWith(...nodes: (Node | string)[]): void {
+    if (!this.parentNode) return;
+    this.before(...nodes);
+    this.remove();
+  }
 }
-// TextNode is now in a separate file
+// TextNode is now in a separate file