defuddle-cli 0.1.4 → 0.3.0

package/dist/dom/document.d.ts

@@ -0,0 +1,3 @@
+import { SetupFunction } from './setup.js';
+export declare const setupDocumentMethods: SetupFunction;
+export declare const setupWindowMethods: SetupFunction;

package/dist/dom/document.js

@@ -0,0 +1,49 @@
+export const setupDocumentMethods = (window) => {
+    if (!window.Document.prototype.getSelection) {
+        window.Document.prototype.getSelection = function () {
+            const selection = {
+                anchorNode: null,
+                anchorOffset: 0,
+                direction: 'forward',
+                focusNode: null,
+                focusOffset: 0,
+                isCollapsed: true,
+                rangeCount: 0,
+                type: 'None',
+                getRangeAt: function () { return new window.Range(); },
+                removeAllRanges: function () { },
+                addRange: function () { },
+                collapse: function () { },
+                collapseToEnd: function () { },
+                collapseToStart: function () { },
+                deleteFromDocument: function () { },
+                empty: function () { },
+                extend: function () { },
+                modify: function () { },
+                selectAllChildren: function () { },
+                setBaseAndExtent: function () { },
+                setPosition: function () { },
+                toString: function () { return ''; },
+                containsNode: function (node, allowPartialContainment = false) {
+                    return false;
+                },
+                removeRange: function (range) { }
+            };
+            return selection;
+        };
+    }
+};
+export const setupWindowMethods = (window) => {
+    if (!window.Window.prototype.getComputedStyle) {
+        window.Window.prototype.getComputedStyle = function (elt, pseudoElt) {
+            const style = {
+                accentColor: '',
+                alignContent: '',
+                alignItems: '',
+                alignSelf: '',
+                getPropertyValue: function (prop) { return ''; }
+            };
+            return style;
+        };
+    }
+};

package/dist/dom/elements.d.ts

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

package/dist/dom/elements.js

@@ -0,0 +1,478 @@
+export function setupElements(window) {
+    // Define HTMLElement globally
+    globalThis.HTMLElement = window.HTMLElement;
+    // Add window to global scope
+    globalThis.window = window;
+    // Add document to global scope
+    globalThis.document = window.document;
+    // Add required DOM interfaces to global scope
+    globalThis.Element = window.Element;
+    globalThis.Node = window.Node;
+    globalThis.NodeFilter = window.NodeFilter;
+    globalThis.Range = window.Range;
+    globalThis.DOMParser = window.DOMParser;
+    globalThis.XMLSerializer = window.XMLSerializer;
+    // Handle navigator property
+    if (!globalThis.navigator || Object.getOwnPropertyDescriptor(globalThis, 'navigator')?.configurable) {
+        Object.defineProperty(globalThis, 'navigator', {
+            value: window.navigator,
+            writable: false,
+            configurable: true
+        });
+    }
+    // Define DOMSettableTokenList
+    globalThis.DOMSettableTokenList = class {
+        constructor() {
+            this.length = 0;
+            this.value = '';
+        }
+        add(token) { }
+        contains(token) { return false; }
+        item(index) { return null; }
+        remove(token) { }
+        replace(oldToken, newToken) { return false; }
+        supports(token) { return false; }
+        toggle(token, force) { return false; }
+        [Symbol.iterator]() {
+            return function* () { yield ''; return undefined; }();
+        }
+    };
+    // Define SVGElement globally
+    globalThis.SVGElement = class {
+        constructor() {
+            this.id = '';
+            this.className = '';
+            this.style = {
+                cssText: '',
+                length: 0,
+                parentRule: null,
+                getPropertyPriority: () => '',
+                getPropertyValue: () => '',
+                item: () => '',
+                removeProperty: () => '',
+                setProperty: () => '',
+                [Symbol.iterator]: function* () { yield ''; return undefined; }
+            };
+            this.ownerSVGElement = null;
+            this.viewportElement = null;
+            this.tagName = '';
+            this.namespaceURI = null;
+            this.prefix = null;
+            this.localName = '';
+            this.baseURI = '';
+            this.textContent = '';
+            this.innerHTML = '';
+            this.outerHTML = '';
+            this.hidden = false;
+            this.slot = '';
+            this.attributes = {
+                length: 0,
+                getNamedItem: () => null,
+                getNamedItemNS: () => null,
+                item: () => null,
+                removeNamedItem: () => null,
+                removeNamedItemNS: () => null,
+                setNamedItem: () => null,
+                setNamedItemNS: () => null,
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+            this.childNodes = {
+                length: 0,
+                item: () => null,
+                forEach: () => { },
+                entries: function* () { yield [0, null]; return undefined; },
+                keys: function* () { yield 0; return undefined; },
+                values: function* () { yield null; return undefined; },
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+            this.firstChild = null;
+            this.lastChild = null;
+            this.nextSibling = null;
+            this.previousSibling = null;
+            this.parentNode = null;
+            this.parentElement = null;
+            this.childElementCount = 0;
+            this.firstElementChild = null;
+            this.lastElementChild = null;
+            this.nextElementSibling = null;
+            this.previousElementSibling = null;
+            this.children = {
+                length: 0,
+                item: () => null,
+                namedItem: () => null,
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+            // Initialize any required properties
+        }
+        getAttribute(name) {
+            return null;
+        }
+        getAttributeNS(namespaceURI, localName) {
+            return null;
+        }
+        setAttribute(name, value) { }
+        setAttributeNS(namespaceURI, qualifiedName, value) { }
+        removeAttributeNS(namespaceURI, localName) { }
+        hasAttribute(name) {
+            return false;
+        }
+        hasAttributeNS(namespaceURI, localName) {
+            return false;
+        }
+        getBoundingClientRect() {
+            return {
+                top: 0,
+                left: 0,
+                bottom: 0,
+                right: 0,
+                width: 0,
+                height: 0,
+                x: 0,
+                y: 0,
+                toJSON: function () { return this; }
+            };
+        }
+        getClientRects() {
+            return {
+                length: 0,
+                item: function () { return null; },
+                [Symbol.iterator]: function* () { }
+            };
+        }
+        getElementsByClassName(classNames) {
+            return {
+                length: 0,
+                item: () => null,
+                namedItem: () => null,
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+        }
+        getElementsByTagName(qualifiedName) {
+            return {
+                length: 0,
+                item: () => null,
+                namedItem: () => null,
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+        }
+        getElementsByTagNameNS(namespaceURI, localName) {
+            return {
+                length: 0,
+                item: () => null,
+                namedItem: () => null,
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+        }
+        querySelector(selectors) {
+            return null;
+        }
+        querySelectorAll(selectors) {
+            return {
+                length: 0,
+                item: () => null,
+                forEach: () => { },
+                entries: function* () { yield [0, null]; return undefined; },
+                keys: function* () { yield 0; return undefined; },
+                values: function* () { yield null; return undefined; },
+                [Symbol.iterator]: function* () { yield null; return undefined; }
+            };
+        }
+        matches(selectors) {
+            return false;
+        }
+        closest(selectors) {
+            return null;
+        }
+        contains(other) {
+            return false;
+        }
+        append(...nodes) { }
+        prepend(...nodes) { }
+        after(...nodes) { }
+        before(...nodes) { }
+        replaceWith(...nodes) { }
+        remove() { }
+        insertAdjacentElement(where, element) {
+            return null;
+        }
+        insertAdjacentText(where, data) { }
+        insertAdjacentHTML(position, text) { }
+        replaceChildren(...nodes) { }
+    };
+    // Define HTMLImageElement globally
+    globalThis.HTMLImageElement = 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 HTML element types
+    globalThis.HTMLIFrameElement = 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 = '';
+        }
+    };
+    globalThis.HTMLOListElement = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.type = '';
+            this.compact = false;
+            this.reversed = false;
+            this.start = 0;
+        }
+    };
+    globalThis.HTMLUListElement = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.type = '';
+            this.compact = false;
+        }
+    };
+    globalThis.HTMLTableElement = 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) { }
+    };
+    globalThis.HTMLTableRowElement = 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) { }
+    };
+    globalThis.HTMLTableCellElement = 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 = '';
+        }
+    };
+    globalThis.HTMLTableSectionElement = 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) { }
+    };
+    globalThis.HTMLTableCaptionElement = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.align = '';
+        }
+    };
+    globalThis.HTMLButtonElement = 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;
+        }
+    };
+    // HTMLSpanElement interface
+    globalThis.HTMLSpanElement = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+        }
+    };
+    // HTMLDivElement interface
+    globalThis.HTMLDivElement = class extends globalThis.HTMLElement {
+        constructor() {
+            super();
+            this.align = '';
+        }
+    };
+    globalThis.HTMLAnchorElement = 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 = '';
+        }
+    };
+}

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

@@ -0,0 +1,14 @@
+import { DOMWindow } from 'jsdom';
+export interface DOMSettableTokenList {
+    length: number;
+    value: string;
+    add(token: string): void;
+    contains(token: string): boolean;
+    item(index: number): string | null;
+    remove(token: string): void;
+    replace(oldToken: string, newToken: string): boolean;
+    supports(token: string): boolean;
+    toggle(token: string, force?: boolean): boolean;
+    [Symbol.iterator](): Iterator<string>;
+}
+export declare function setupBaseElements(window: DOMWindow): void;

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

@@ -0,0 +1,46 @@
+export function setupBaseElements(window) {
+    // Define DOMSettableTokenList
+    const DOMSettableTokenListClass = class {
+        constructor() {
+            this.length = 0;
+            this.value = '';
+        }
+        add(token) { }
+        contains(token) { return false; }
+        item(index) { return null; }
+        remove(token) { }
+        replace(oldToken, newToken) { return false; }
+        supports(token) { return false; }
+        toggle(token, force) { return false; }
+        [Symbol.iterator]() {
+            return function* () { yield ''; return undefined; }();
+        }
+    };
+    // Define globally
+    globalThis.DOMSettableTokenList = DOMSettableTokenListClass;
+    // Define SVGElement globally
+    const SVGElementClass = class {
+        constructor() {
+            this.id = '';
+            this.className = '';
+            this.style = {
+                cssText: '',
+                length: 0,
+                parentRule: null,
+                getPropertyPriority: () => '',
+                getPropertyValue: () => '',
+                item: () => '',
+                removeProperty: () => '',
+                setProperty: () => '',
+                [Symbol.iterator]: function* () { yield ''; return undefined; }
+            };
+            // ... rest of SVGElement implementation
+        }
+    };
+    // Define globally
+    globalThis.SVGElement = SVGElementClass;
+    // Assign to window if not already present
+    if (!window.SVGElement) {
+        window.SVGElement = SVGElementClass;
+    }
+}

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

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