@dooboostore/dom-parser 1.0.0

package/src/node/elements/HTMLInputElement.ts

@@ -0,0 +1,160 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLInputElement`** class represents an HTML `<input>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLInputElement)
+ */
+export class HTMLInputElement extends HTMLElementBase {
+    private _type: string = 'text';
+    private _value: string = '';
+    private _placeholder: string = '';
+    private _disabled: boolean = false;
+    private _readonly: boolean = false;
+    private _required: boolean = false;
+    private _checked: boolean = false;
+
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+
+    get type(): string {
+        return this._type;
+    }
+
+    set type(value: string) {
+        this._type = value;
+        this.setAttribute('type', value);
+    }
+
+    get value(): string {
+        return this._value;
+    }
+
+    set value(value: string) {
+        this._value = value;
+        this.setAttribute('value', value);
+    }
+
+    get placeholder(): string {
+        return this._placeholder;
+    }
+
+    set placeholder(value: string) {
+        this._placeholder = value;
+        this.setAttribute('placeholder', value);
+    }
+
+    get disabled(): boolean {
+        return this._disabled;
+    }
+
+    set disabled(value: boolean) {
+        this._disabled = value;
+        if (value) {
+            this.setAttribute('disabled', '');
+        } else {
+            this.removeAttribute('disabled');
+        }
+    }
+
+    get readOnly(): boolean {
+        return this._readonly;
+    }
+
+    set readOnly(value: boolean) {
+        this._readonly = value;
+        if (value) {
+            this.setAttribute('readonly', '');
+        } else {
+            this.removeAttribute('readonly');
+        }
+    }
+
+    get required(): boolean {
+        return this._required;
+    }
+
+    set required(value: boolean) {
+        this._required = value;
+        if (value) {
+            this.setAttribute('required', '');
+        } else {
+            this.removeAttribute('required');
+        }
+    }
+
+    get checked(): boolean {
+        return this._checked;
+    }
+
+    set checked(value: boolean) {
+        this._checked = value;
+        if (value) {
+            this.setAttribute('checked', '');
+        } else {
+            this.removeAttribute('checked');
+        }
+    }
+
+    // Override setAttribute to sync with properties
+    setAttribute(qualifiedName: string, value: string): void {
+        super.setAttribute(qualifiedName, value);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'type':
+                this._type = value;
+                break;
+            case 'value':
+                this._value = value;
+                break;
+            case 'placeholder':
+                this._placeholder = value;
+                break;
+            case 'disabled':
+                this._disabled = true;
+                break;
+            case 'readonly':
+                this._readonly = true;
+                break;
+            case 'required':
+                this._required = true;
+                break;
+            case 'checked':
+                this._checked = true;
+                break;
+        }
+    }
+
+    // Override removeAttribute to sync with properties
+    removeAttribute(qualifiedName: string): void {
+        super.removeAttribute(qualifiedName);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'type':
+                this._type = 'text';
+                break;
+            case 'value':
+                this._value = '';
+                break;
+            case 'placeholder':
+                this._placeholder = '';
+                break;
+            case 'disabled':
+                this._disabled = false;
+                break;
+            case 'readonly':
+                this._readonly = false;
+                break;
+            case 'required':
+                this._required = false;
+                break;
+            case 'checked':
+                this._checked = false;
+                break;
+        }
+    }
+}

package/src/node/elements/HTMLLIElement.ts

@@ -0,0 +1,47 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLLIElement`** class represents an HTML `<li>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLLIElement)
+ */
+export class HTMLLIElement extends HTMLElementBase {
+    private _value: number = 0;
+    
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get value(): number {
+        return this._value;
+    }
+
+    set value(value: number) {
+        this._value = value;
+        this.setAttribute('value', value.toString());
+    }
+
+    // Override setAttribute to sync with properties
+    setAttribute(qualifiedName: string, value: string): void {
+        super.setAttribute(qualifiedName, value);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'value':
+                this._value = parseInt(value, 10) || 0;
+                break;
+        }
+    }
+
+    // Override removeAttribute to sync with properties
+    removeAttribute(qualifiedName: string): void {
+        super.removeAttribute(qualifiedName);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'value':
+                this._value = 0;
+                break;
+        }
+    }
+}

package/src/node/elements/HTMLLinkElement.ts

@@ -0,0 +1,95 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLLinkElement`** class represents an HTML `<link>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLLinkElement)
+ */
+export class HTMLLinkElement extends HTMLElementBase {
+    private _href: string = '';
+    private _rel: string = '';
+    private _type: string = '';
+    private _media: string = '';
+    
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get href(): string {
+        return this._href;
+    }
+
+    set href(value: string) {
+        this._href = value;
+        this.setAttribute('href', value);
+    }
+
+    get rel(): string {
+        return this._rel;
+    }
+
+    set rel(value: string) {
+        this._rel = value;
+        this.setAttribute('rel', value);
+    }
+
+    get type(): string {
+        return this._type;
+    }
+
+    set type(value: string) {
+        this._type = value;
+        this.setAttribute('type', value);
+    }
+
+    get media(): string {
+        return this._media;
+    }
+
+    set media(value: string) {
+        this._media = value;
+        this.setAttribute('media', value);
+    }
+
+    // Override setAttribute to sync with properties
+    setAttribute(qualifiedName: string, value: string): void {
+        super.setAttribute(qualifiedName, value);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'href':
+                this._href = value;
+                break;
+            case 'rel':
+                this._rel = value;
+                break;
+            case 'type':
+                this._type = value;
+                break;
+            case 'media':
+                this._media = value;
+                break;
+        }
+    }
+
+    // Override removeAttribute to sync with properties
+    removeAttribute(qualifiedName: string): void {
+        super.removeAttribute(qualifiedName);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'href':
+                this._href = '';
+                break;
+            case 'rel':
+                this._rel = '';
+                break;
+            case 'type':
+                this._type = '';
+                break;
+            case 'media':
+                this._media = '';
+                break;
+        }
+    }
+}

package/src/node/elements/HTMLMetaElement.ts

@@ -0,0 +1,12 @@
+import { ElementBase } from './ElementBase';
+
+/**
+ * The **`HTMLMetaElement`** class represents an HTML `<meta>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLMetaElement)
+ */
+export class HTMLMetaElement extends ElementBase {
+    constructor(tagName: string, ownerDocument?: any){
+        super(tagName, ownerDocument);
+    }
+}

package/src/node/elements/HTMLOListElement.ts

@@ -0,0 +1,83 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLOListElement`** class represents an HTML `<ol>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLOListElement)
+ */
+export class HTMLOListElement extends HTMLElementBase {
+    private _start: number = 1;
+    private _type: string = '';
+    private _reversed: boolean = false;
+    
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get start(): number {
+        return this._start;
+    }
+
+    set start(value: number) {
+        this._start = value;
+        this.setAttribute('start', value.toString());
+    }
+
+    get type(): string {
+        return this._type;
+    }
+
+    set type(value: string) {
+        this._type = value;
+        this.setAttribute('type', value);
+    }
+
+    get reversed(): boolean {
+        return this._reversed;
+    }
+
+    set reversed(value: boolean) {
+        this._reversed = value;
+        if (value) {
+            this.setAttribute('reversed', '');
+        } else {
+            this.removeAttribute('reversed');
+        }
+    }
+
+    // Override setAttribute to sync with properties
+    setAttribute(qualifiedName: string, value: string): void {
+        super.setAttribute(qualifiedName, value);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'start':
+                this._start = parseInt(value, 10) || 1;
+                break;
+            case 'type':
+                this._type = value;
+                break;
+            case 'reversed':
+                this._reversed = true;
+                break;
+        }
+    }
+
+    // Override removeAttribute to sync with properties
+    removeAttribute(qualifiedName: string): void {
+        super.removeAttribute(qualifiedName);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'start':
+                this._start = 1;
+                break;
+            case 'type':
+                this._type = '';
+                break;
+            case 'reversed':
+                this._reversed = false;
+                break;
+        }
+    }
+}

package/src/node/elements/HTMLPElement.ts

@@ -0,0 +1,12 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLPElement`** class represents an HTML `<p>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLParagraphElement)
+ */
+export class HTMLPElement extends HTMLElementBase  {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+}

package/src/node/elements/HTMLScriptElement.ts

@@ -0,0 +1,127 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLScriptElement`** class represents an HTML `<script>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLScriptElement)
+ */
+export class HTMLScriptElement extends HTMLElementBase {
+    private _src: string = '';
+    private _type: string = 'text/javascript';
+    private _async: boolean = false;
+    private _defer: boolean = false;
+    private _crossOrigin: string = '';
+    
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get src(): string {
+        return this._src;
+    }
+
+    set src(value: string) {
+        this._src = value;
+        this.setAttribute('src', value);
+    }
+
+    get type(): string {
+        return this._type;
+    }
+
+    set type(value: string) {
+        this._type = value;
+        this.setAttribute('type', value);
+    }
+
+    get async(): boolean {
+        return this._async;
+    }
+
+    set async(value: boolean) {
+        this._async = value;
+        if (value) {
+            this.setAttribute('async', '');
+        } else {
+            this.removeAttribute('async');
+        }
+    }
+
+    get defer(): boolean {
+        return this._defer;
+    }
+
+    set defer(value: boolean) {
+        this._defer = value;
+        if (value) {
+            this.setAttribute('defer', '');
+        } else {
+            this.removeAttribute('defer');
+        }
+    }
+
+    get crossOrigin(): string {
+        return this._crossOrigin;
+    }
+
+    set crossOrigin(value: string) {
+        this._crossOrigin = value;
+        this.setAttribute('crossorigin', value);
+    }
+
+    get text(): string {
+        return this.textContent || '';
+    }
+
+    set text(value: string) {
+        this.textContent = value;
+    }
+
+    // Override setAttribute to sync with properties
+    setAttribute(qualifiedName: string, value: string): void {
+        super.setAttribute(qualifiedName, value);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'src':
+                this._src = value;
+                break;
+            case 'type':
+                this._type = value;
+                break;
+            case 'async':
+                this._async = true;
+                break;
+            case 'defer':
+                this._defer = true;
+                break;
+            case 'crossorigin':
+                this._crossOrigin = value;
+                break;
+        }
+    }
+
+    // Override removeAttribute to sync with properties
+    removeAttribute(qualifiedName: string): void {
+        super.removeAttribute(qualifiedName);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'src':
+                this._src = '';
+                break;
+            case 'type':
+                this._type = 'text/javascript';
+                break;
+            case 'async':
+                this._async = false;
+                break;
+            case 'defer':
+                this._defer = false;
+                break;
+            case 'crossorigin':
+                this._crossOrigin = '';
+                break;
+        }
+    }
+}

package/src/node/elements/HTMLSpanElement.ts

@@ -0,0 +1,12 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLSpanElement`** class represents an HTML `<span>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLSpanElement)
+ */
+export class HTMLSpanElement extends HTMLElementBase {
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+}

package/src/node/elements/HTMLStyleElement.ts

@@ -0,0 +1,63 @@
+import { HTMLElementBase } from './HTMLElementBase';
+
+/**
+ * The **`HTMLStyleElement`** class represents an HTML `<style>` element.
+ * 
+ * [MDN Reference](https://developer.mozilla.org/docs/Web/API/HTMLStyleElement)
+ */
+export class HTMLStyleElement extends HTMLElementBase {
+    private _type: string = 'text/css';
+    private _media: string = '';
+    
+    constructor(tagName: string, ownerDocument?: any) {
+        super(tagName, ownerDocument);
+    }
+
+    get type(): string {
+        return this._type;
+    }
+
+    set type(value: string) {
+        this._type = value;
+        this.setAttribute('type', value);
+    }
+
+    get media(): string {
+        return this._media;
+    }
+
+    set media(value: string) {
+        this._media = value;
+        this.setAttribute('media', value);
+    }
+
+    // Override setAttribute to sync with properties
+    setAttribute(qualifiedName: string, value: string): void {
+        super.setAttribute(qualifiedName, value);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'type':
+                this._type = value;
+                break;
+            case 'media':
+                this._media = value;
+                break;
+        }
+    }
+
+    // Override removeAttribute to sync with properties
+    removeAttribute(qualifiedName: string): void {
+        super.removeAttribute(qualifiedName);
+        
+        const name = qualifiedName.toLowerCase();
+        switch (name) {
+            case 'type':
+                this._type = 'text/css';
+                break;
+            case 'media':
+                this._media = '';
+                break;
+        }
+    }
+}