defuddle-cli 0.1.4 → 0.3.0

package/dist/dom/interfaces/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/range.d.ts

@@ -1,2 +1,2 @@
-import { SetupFunction } from './setup.js';
+import { SetupFunction } from '../types/setup.js';
 export declare const setupRange: SetupFunction;

package/dist/dom/range.d.ts

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

package/dist/dom/range.js

@@ -0,0 +1,87 @@
+export const setupRange = (window) => {
+    var _a;
+    if (!window.Range) {
+        window.Range = (_a = class Range {
+                constructor() {
+                    this.START_TO_START = 0;
+                    this.START_TO_END = 1;
+                    this.END_TO_END = 2;
+                    this.END_TO_START = 3;
+                    this.startContainer = document.documentElement;
+                    this.startOffset = 0;
+                    this.endContainer = document.documentElement;
+                    this.endOffset = 0;
+                    this.collapsed = true;
+                    this.commonAncestorContainer = document.documentElement;
+                }
+                createContextualFragment(fragment) {
+                    return document.createDocumentFragment();
+                }
+                detach() { }
+                cloneContents() {
+                    return document.createDocumentFragment();
+                }
+                cloneRange() {
+                    return new _a();
+                }
+                collapse(toStart = false) { }
+                compareBoundaryPoints(how, sourceRange) {
+                    return 0;
+                }
+                comparePoint(node, offset) {
+                    return 0;
+                }
+                deleteContents() { }
+                extractContents() {
+                    return document.createDocumentFragment();
+                }
+                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* () { }
+                    };
+                }
+                insertNode(node) { }
+                intersectsNode(node) {
+                    return false;
+                }
+                isPointInRange(node, offset) {
+                    return false;
+                }
+                selectNode(node) { }
+                selectNodeContents(node) {
+                    this.startContainer = node;
+                    this.startOffset = 0;
+                    this.endContainer = node;
+                    this.endOffset = node.childNodes.length;
+                    this.collapsed = false;
+                }
+                setEnd(node, offset) { }
+                setEndAfter(node) { }
+                setEndBefore(node) { }
+                setStart(node, offset) { }
+                setStartAfter(node) { }
+                setStartBefore(node) { }
+                surroundContents(newParent) { }
+            },
+            _a.START_TO_START = 0,
+            _a.START_TO_END = 1,
+            _a.END_TO_END = 2,
+            _a.END_TO_START = 3,
+            _a);
+    }
+};

package/dist/dom/setup/document.d.ts

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

package/dist/dom/setup/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/setup.d.ts

@@ -1,9 +1,12 @@
-import { JSDOM } from 'jsdom';
-/**
- * Creates a virtual DOM instance with the given HTML content
- */
-export declare function createVirtualDOM(html: string, url?: string): JSDOM;
-/**
- * Sets up additional document properties
- */
-export declare function setupDocumentProperties(doc: Document): void;
+import { DOMWindow } from 'jsdom';
+export type SetupFunction = (window: DOMWindow) => void;
+export declare const setupBasicWindow: SetupFunction;
+export declare const setupCSSInterfaces: SetupFunction;
+export declare const setupHTMLAndSVG: SetupFunction;
+export declare const setupScreen: SetupFunction;
+export declare const setupStorage: SetupFunction;
+export declare const setupAnimationFrame: SetupFunction;
+export declare const setupDOMMethods: SetupFunction;
+export declare const setupNodeMethods: SetupFunction;
+export declare const setupElementMethods: SetupFunction;
+export declare const setupDOMInterfaces: (window: DOMWindow) => void;