defuddle-cli 0.2.0 → 0.3.1

package/dist/dom/interfaces/elements/form.js

@@ -0,0 +1,123 @@
+export function setupFormElements(window) {
+    // HTMLButtonElement
+    const HTMLButtonElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.disabled = false;
+            this.form = null;
+            this.formAction = '';
+            this.formEnctype = '';
+            this.formMethod = '';
+            this.formNoValidate = false;
+            this.formTarget = '';
+            this.name = '';
+            this.type = 'submit';
+            this.value = '';
+            this.menu = null;
+        }
+    };
+    // HTMLFormElement
+    const HTMLFormElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.acceptCharset = '';
+            this.action = '';
+            this.autocomplete = '';
+            this.enctype = '';
+            this.encoding = '';
+            this.method = '';
+            this.name = '';
+            this.noValidate = false;
+            this.target = '';
+            this.elements = {
+                length: 0,
+                item: () => null,
+                namedItem: () => null,
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+            this.length = 0;
+        }
+        submit() { }
+        reset() { }
+        checkValidity() { return true; }
+        reportValidity() { return true; }
+    };
+    // HTMLInputElement
+    const HTMLInputElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.accept = '';
+            this.alt = '';
+            this.autocomplete = '';
+            this.autofocus = false;
+            this.defaultChecked = false;
+            this.checked = false;
+            this.dirName = '';
+            this.disabled = false;
+            this.form = null;
+            this.files = null;
+            this.formAction = '';
+            this.formEnctype = '';
+            this.formMethod = '';
+            this.formNoValidate = false;
+            this.formTarget = '';
+            this.height = 0;
+            this.indeterminate = false;
+            this.list = null;
+            this.max = '';
+            this.maxLength = -1;
+            this.min = '';
+            this.minLength = -1;
+            this.multiple = false;
+            this.name = '';
+            this.pattern = '';
+            this.placeholder = '';
+            this.readOnly = false;
+            this.required = false;
+            this.size = 0;
+            this.src = '';
+            this.step = '';
+            this.type = 'text';
+            this.defaultValue = '';
+            this.value = '';
+            this.valueAsDate = null;
+            this.valueAsNumber = 0;
+            this.width = 0;
+            this.willValidate = false;
+            this.validity = {
+                badInput: false,
+                customError: false,
+                patternMismatch: false,
+                rangeOverflow: false,
+                rangeUnderflow: false,
+                stepMismatch: false,
+                tooLong: false,
+                tooShort: false,
+                typeMismatch: false,
+                valid: true,
+                valueMissing: false
+            };
+        }
+        stepUp(n) { }
+        stepDown(n) { }
+        checkValidity() { return true; }
+        reportValidity() { return true; }
+        select() { }
+        setRangeText(replacement, start, end, selectionMode) { }
+        setCustomValidity(error) { }
+    };
+    // Define globally
+    globalThis.HTMLButtonElement = HTMLButtonElementClass;
+    globalThis.HTMLFormElement = HTMLFormElementClass;
+    globalThis.HTMLInputElement = HTMLInputElementClass;
+    // Assign to window if not already present
+    if (!window.HTMLButtonElement) {
+        window.HTMLButtonElement = HTMLButtonElementClass;
+    }
+    if (!window.HTMLFormElement) {
+        window.HTMLFormElement = HTMLFormElementClass;
+    }
+    if (!window.HTMLInputElement) {
+        window.HTMLInputElement = HTMLInputElementClass;
+    }
+}

package/dist/dom/interfaces/elements/index.d.ts

@@ -0,0 +1,2 @@
+import { DOMWindow } from 'jsdom';
+export declare function setupElements(window: DOMWindow): void;

package/dist/dom/interfaces/elements/index.js

@@ -0,0 +1,22 @@
+import { setupBaseElements } from './base.js';
+import { setupMediaElements } from './media.js';
+import { setupTableElements } from './table.js';
+import { setupFormElements } from './form.js';
+import { setupTextElements } from './text.js';
+import { setupInteractiveElements } from './interactive.js';
+export function setupElements(window) {
+    // First set up base elements which define HTMLElement
+    setupBaseElements(window);
+    // Then set up all other elements that extend from HTMLElement
+    // We need to ensure HTMLElement is available in globalThis
+    if (!globalThis.HTMLElement) {
+        globalThis.HTMLElement = window.HTMLElement;
+    }
+    // Now we can safely set up all other elements
+    setupMediaElements(window);
+    setupTableElements(window);
+    setupFormElements(window);
+    setupTextElements(window);
+    setupInteractiveElements(window);
+    // Add other element setup functions as they are created
+}

package/dist/dom/interfaces/elements/interactive.d.ts

@@ -0,0 +1,2 @@
+import { DOMWindow } from 'jsdom';
+export declare function setupInteractiveElements(window: DOMWindow): void;

package/dist/dom/interfaces/elements/interactive.js

@@ -0,0 +1,83 @@
+export function setupInteractiveElements(window) {
+    // HTMLAnchorElement
+    const HTMLAnchorElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.href = '';
+            this.target = '';
+            this.download = '';
+            this.ping = '';
+            this.rel = '';
+            this.relList = {
+                length: 0,
+                value: '',
+                add: () => { },
+                contains: () => false,
+                item: () => null,
+                remove: () => { },
+                replace: () => false,
+                supports: () => false,
+                toggle: () => false,
+                [Symbol.iterator]: function* () { yield ''; return undefined; }
+            };
+            this.hreflang = '';
+            this.type = '';
+            this.text = '';
+            this.referrerPolicy = '';
+            this.origin = '';
+            this.protocol = '';
+            this.username = '';
+            this.password = '';
+            this.host = '';
+            this.hostname = '';
+            this.port = '';
+            this.pathname = '';
+            this.search = '';
+            this.hash = '';
+        }
+    };
+    // HTMLIFrameElement
+    const HTMLIFrameElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.align = '';
+            this.allow = '';
+            this.allowFullscreen = false;
+            this.contentDocument = null;
+            this.contentWindow = null;
+            this.frameBorder = '';
+            this.height = '';
+            this.longDesc = '';
+            this.marginHeight = '';
+            this.marginWidth = '';
+            this.name = '';
+            this.referrerPolicy = '';
+            this.sandbox = {
+                length: 0,
+                value: '',
+                add: () => { },
+                contains: () => false,
+                item: () => null,
+                remove: () => { },
+                replace: () => false,
+                supports: () => false,
+                toggle: () => false,
+                [Symbol.iterator]: function* () { yield ''; return undefined; }
+            };
+            this.scrolling = '';
+            this.src = '';
+            this.srcdoc = '';
+            this.width = '';
+        }
+    };
+    // Define globally
+    globalThis.HTMLAnchorElement = HTMLAnchorElementClass;
+    globalThis.HTMLIFrameElement = HTMLIFrameElementClass;
+    // Assign to window if not already present
+    if (!window.HTMLAnchorElement) {
+        window.HTMLAnchorElement = HTMLAnchorElementClass;
+    }
+    if (!window.HTMLIFrameElement) {
+        window.HTMLIFrameElement = HTMLIFrameElementClass;
+    }
+}

package/dist/dom/interfaces/elements/media.d.ts

@@ -0,0 +1,2 @@
+import { DOMWindow } from 'jsdom';
+export declare function setupMediaElements(window: DOMWindow): void;

package/dist/dom/interfaces/elements/media.js

@@ -0,0 +1,43 @@
+export function setupMediaElements(window) {
+    // Define HTMLImageElement globally
+    const HTMLImageElementClass = class {
+        constructor() {
+            this.alt = '';
+            this.src = '';
+            this.srcset = '';
+            this.sizes = '';
+            this.crossOrigin = null;
+            this.useMap = '';
+            this.isMap = false;
+            this.width = 0;
+            this.height = 0;
+            this.naturalWidth = 0;
+            this.naturalHeight = 0;
+            this.complete = false;
+            this.name = '';
+            this.lowsrc = '';
+            this.align = '';
+            this.hspace = 0;
+            this.vspace = 0;
+            this.longDesc = '';
+            this.border = '';
+            this.x = 0;
+            this.y = 0;
+            this.currentSrc = '';
+            this.decoding = 'auto';
+            this.fetchPriority = 'auto';
+            this.loading = 'eager';
+            this.referrerPolicy = '';
+            // Initialize any required properties
+        }
+        decode() {
+            return Promise.resolve();
+        }
+    };
+    // Define globally
+    globalThis.HTMLImageElement = HTMLImageElementClass;
+    // Assign to window if not already present
+    if (!window.HTMLImageElement) {
+        window.HTMLImageElement = HTMLImageElementClass;
+    }
+}

package/dist/dom/interfaces/elements/table.d.ts

@@ -0,0 +1,2 @@
+import { DOMWindow } from 'jsdom';
+export declare function setupTableElements(window: DOMWindow): void;

package/dist/dom/interfaces/elements/table.js

@@ -0,0 +1,155 @@
+export function setupTableElements(window) {
+    // HTMLTableElement
+    const HTMLTableElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.caption = null;
+            this.tHead = null;
+            this.tFoot = null;
+            this.tBodies = {
+                length: 0,
+                item: () => null,
+                namedItem: () => null,
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+            this.rows = {
+                length: 0,
+                item: () => null,
+                namedItem: () => null,
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+            this.align = '';
+            this.bgColor = '';
+            this.border = '';
+            this.cellPadding = '';
+            this.cellSpacing = '';
+            this.frame = '';
+            this.rules = '';
+            this.summary = '';
+            this.width = '';
+        }
+        createCaption() {
+            return new globalThis.HTMLTableCaptionElement();
+        }
+        deleteCaption() { }
+        createTHead() {
+            return new globalThis.HTMLTableSectionElement();
+        }
+        deleteTHead() { }
+        createTFoot() {
+            return new globalThis.HTMLTableSectionElement();
+        }
+        deleteTFoot() { }
+        createTBody() {
+            return new globalThis.HTMLTableSectionElement();
+        }
+        insertRow(index) {
+            return new globalThis.HTMLTableRowElement();
+        }
+        deleteRow(index) { }
+    };
+    // HTMLTableRowElement
+    const HTMLTableRowElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.rowIndex = 0;
+            this.sectionRowIndex = 0;
+            this.cells = {
+                length: 0,
+                item: () => null,
+                namedItem: () => null,
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+            this.align = '';
+            this.bgColor = '';
+            this.ch = '';
+            this.chOff = '';
+            this.vAlign = '';
+        }
+        insertCell(index) {
+            return new globalThis.HTMLTableCellElement();
+        }
+        deleteCell(index) { }
+    };
+    // HTMLTableCellElement
+    const HTMLTableCellElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.colSpan = 1;
+            this.rowSpan = 1;
+            this.headers = {
+                length: 0,
+                value: '',
+                add: () => { },
+                contains: () => false,
+                item: () => null,
+                remove: () => { },
+                replace: () => false,
+                supports: () => false,
+                toggle: () => false,
+                [Symbol.iterator]: function* () { yield ''; return undefined; }
+            };
+            this.cellIndex = 0;
+            this.scope = '';
+            this.abbr = '';
+            this.align = '';
+            this.axis = '';
+            this.bgColor = '';
+            this.ch = '';
+            this.chOff = '';
+            this.height = '';
+            this.noWrap = false;
+            this.vAlign = '';
+            this.width = '';
+        }
+    };
+    // HTMLTableSectionElement
+    const HTMLTableSectionElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.rows = {
+                length: 0,
+                item: () => null,
+                namedItem: () => null,
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+            this.align = '';
+            this.ch = '';
+            this.chOff = '';
+            this.vAlign = '';
+        }
+        insertRow(index) {
+            return new globalThis.HTMLTableRowElement();
+        }
+        deleteRow(index) { }
+    };
+    // HTMLTableCaptionElement
+    const HTMLTableCaptionElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.align = '';
+        }
+    };
+    // Define globally
+    globalThis.HTMLTableElement = HTMLTableElementClass;
+    globalThis.HTMLTableRowElement = HTMLTableRowElementClass;
+    globalThis.HTMLTableCellElement = HTMLTableCellElementClass;
+    globalThis.HTMLTableSectionElement = HTMLTableSectionElementClass;
+    globalThis.HTMLTableCaptionElement = HTMLTableCaptionElementClass;
+    // Assign to window if not already present
+    if (!window.HTMLTableElement) {
+        window.HTMLTableElement = HTMLTableElementClass;
+    }
+    if (!window.HTMLTableRowElement) {
+        window.HTMLTableRowElement = HTMLTableRowElementClass;
+    }
+    if (!window.HTMLTableCellElement) {
+        window.HTMLTableCellElement = HTMLTableCellElementClass;
+    }
+    if (!window.HTMLTableSectionElement) {
+        window.HTMLTableSectionElement = HTMLTableSectionElementClass;
+    }
+    if (!window.HTMLTableCaptionElement) {
+        window.HTMLTableCaptionElement = HTMLTableCaptionElementClass;
+    }
+}

package/dist/dom/interfaces/elements/text.d.ts

@@ -0,0 +1,2 @@
+import { DOMWindow } from 'jsdom';
+export declare function setupTextElements(window: DOMWindow): void;

package/dist/dom/interfaces/elements/text.js

@@ -0,0 +1,57 @@
+export function setupTextElements(window) {
+    // HTMLSpanElement
+    const HTMLSpanElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+        }
+    };
+    // HTMLDivElement
+    const HTMLDivElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.align = '';
+        }
+    };
+    // HTMLParagraphElement
+    const HTMLParagraphElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.align = '';
+        }
+    };
+    // HTMLHeadingElement
+    const HTMLHeadingElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+        }
+    };
+    // HTMLPreElement
+    const HTMLPreElementClass = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.width = 0;
+        }
+    };
+    // Define globally
+    globalThis.HTMLSpanElement = HTMLSpanElementClass;
+    globalThis.HTMLDivElement = HTMLDivElementClass;
+    globalThis.HTMLParagraphElement = HTMLParagraphElementClass;
+    globalThis.HTMLHeadingElement = HTMLHeadingElementClass;
+    globalThis.HTMLPreElement = HTMLPreElementClass;
+    // Assign to window if not already present
+    if (!window.HTMLSpanElement) {
+        window.HTMLSpanElement = HTMLSpanElementClass;
+    }
+    if (!window.HTMLDivElement) {
+        window.HTMLDivElement = HTMLDivElementClass;
+    }
+    if (!window.HTMLParagraphElement) {
+        window.HTMLParagraphElement = HTMLParagraphElementClass;
+    }
+    if (!window.HTMLHeadingElement) {
+        window.HTMLHeadingElement = HTMLHeadingElementClass;
+    }
+    if (!window.HTMLPreElement) {
+        window.HTMLPreElement = HTMLPreElementClass;
+    }
+}

package/dist/dom/interfaces/elements.d.ts

@@ -0,0 +1,2 @@
+import { DOMWindow } from 'jsdom';
+export declare function setupElements(window: DOMWindow): void;