defuddle-cli 0.1.0 → 0.1.2

package/dist/dom/interfaces/setup.js

@@ -0,0 +1,182 @@
+import { setupDocumentMethods, setupWindowMethods } from './document.js';
+// Setup basic window properties
+export const setupBasicWindow = (window) => {
+    if (!window.innerWidth) {
+        Object.defineProperty(window, 'innerWidth', { value: 1024 });
+    }
+    if (!window.innerHeight) {
+        Object.defineProperty(window, 'innerHeight', { value: 768 });
+    }
+    if (!window.devicePixelRatio) {
+        Object.defineProperty(window, 'devicePixelRatio', { value: 1 });
+    }
+};
+// Setup CSS interfaces
+export const setupCSSInterfaces = (window) => {
+    if (!window.CSSRule) {
+        window.CSSRule = globalThis.CSSRule;
+    }
+    if (!window.CSSMediaRule) {
+        window.CSSMediaRule = globalThis.CSSMediaRule;
+    }
+    if (!window.CSSStyleSheet) {
+        window.CSSStyleSheet = globalThis.CSSStyleSheet;
+    }
+};
+// Setup HTML and SVG interfaces
+export const setupHTMLAndSVG = (window) => {
+    if (!window.HTMLImageElement) {
+        window.HTMLImageElement = globalThis.HTMLImageElement;
+    }
+    if (!window.SVGElement) {
+        window.SVGElement = globalThis.SVGElement;
+    }
+    if (!window.HTMLAnchorElement) {
+        window.HTMLAnchorElement = globalThis.HTMLAnchorElement;
+    }
+};
+// Setup screen object
+export const setupScreen = (window) => {
+    if (!window.screen) {
+        Object.defineProperty(window, 'screen', {
+            value: {
+                width: 1024,
+                height: 768,
+                availWidth: 1024,
+                availHeight: 768,
+                colorDepth: 24,
+                pixelDepth: 24,
+                orientation: {
+                    type: 'landscape-primary',
+                    angle: 0
+                }
+            }
+        });
+    }
+};
+// Setup storage objects
+export const setupStorage = (window) => {
+    const createStorage = () => {
+        const storage = {
+            length: 0,
+            getItem: () => null,
+            setItem: () => { },
+            removeItem: () => { },
+            clear: () => { },
+            key: () => null
+        };
+        // Make the storage object non-extensible
+        Object.preventExtensions(storage);
+        return storage;
+    };
+    try {
+        // Create storage objects
+        const localStorage = createStorage();
+        const sessionStorage = createStorage();
+        // Define properties with more permissive attributes
+        Object.defineProperties(window, {
+            localStorage: {
+                value: localStorage,
+                writable: true,
+                configurable: true
+            },
+            sessionStorage: {
+                value: sessionStorage,
+                writable: true,
+                configurable: true
+            }
+        });
+    }
+    catch (error) {
+        // Log the error but don't throw
+        console.warn('Warning: Could not set up storage objects:', error instanceof Error ? error.message : 'Unknown error');
+    }
+};
+// Setup animation frame methods
+export const setupAnimationFrame = (window) => {
+    if (!window.requestAnimationFrame) {
+        window.requestAnimationFrame = (callback) => {
+            return setTimeout(callback, 0);
+        };
+    }
+    if (!window.cancelAnimationFrame) {
+        window.cancelAnimationFrame = (handle) => {
+            clearTimeout(handle);
+        };
+    }
+};
+// Setup DOM methods
+export const setupDOMMethods = (window) => {
+    if (!window.Document.prototype.getElementsByClassName) {
+        window.Document.prototype.getElementsByClassName = function (classNames) {
+            const elements = this.querySelectorAll('.' + classNames);
+            const collection = new HTMLCollection();
+            elements.forEach((el, i) => {
+                collection[i] = el;
+            });
+            return collection;
+        };
+    }
+};
+// Setup Node methods
+export const setupNodeMethods = (window) => {
+    if (!window.Node.prototype.contains) {
+        window.Node.prototype.contains = function (node) {
+            let current = node;
+            while (current) {
+                if (current === this)
+                    return true;
+                current = current.parentNode;
+            }
+            return false;
+        };
+    }
+};
+// Setup Element methods
+export const setupElementMethods = (window) => {
+    if (!window.Element.prototype.getBoundingClientRect) {
+        window.Element.prototype.getBoundingClientRect = function () {
+            return {
+                top: 0,
+                left: 0,
+                bottom: 0,
+                right: 0,
+                width: 0,
+                height: 0,
+                x: 0,
+                y: 0,
+                toJSON: function () { return this; }
+            };
+        };
+    }
+};
+// Main setup function that orchestrates all the individual setups
+export const setupDOMInterfaces = (window) => {
+    const setupFunctions = [
+        ['basic window', setupBasicWindow],
+        ['CSS interfaces', setupCSSInterfaces],
+        ['HTML and SVG interfaces', setupHTMLAndSVG],
+        ['screen object', setupScreen],
+        ['storage objects', setupStorage],
+        ['animation frame methods', setupAnimationFrame],
+        ['DOM methods', setupDOMMethods],
+        ['Node methods', setupNodeMethods],
+        ['Element methods', setupElementMethods],
+        ['Document methods', setupDocumentMethods],
+        ['Window methods', setupWindowMethods]
+    ];
+    try {
+        for (const [name, setup] of setupFunctions) {
+            try {
+                setup(window);
+            }
+            catch (error) {
+                console.warn(`Warning: Could not set up ${name}:`, error instanceof Error ? error.message : 'Unknown error');
+            }
+        }
+    }
+    catch (error) {
+        console.error('Error in setupDOMInterfaces:', error instanceof Error ? error.message : 'Unknown error');
+        // Don't throw the error, just log it
+    }
+};

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

@@ -0,0 +1,59 @@
+export declare class SVGElement {
+    id: string;
+    className: string;
+    style: CSSStyleDeclaration;
+    ownerSVGElement: SVGElement | null;
+    viewportElement: SVGElement | null;
+    tagName: string;
+    namespaceURI: string | null;
+    prefix: string | null;
+    localName: string;
+    baseURI: string;
+    textContent: string | null;
+    innerHTML: string;
+    outerHTML: string;
+    hidden: boolean;
+    slot: string;
+    attributes: NamedNodeMap;
+    childNodes: NodeListOf<ChildNode>;
+    firstChild: ChildNode | null;
+    lastChild: ChildNode | null;
+    nextSibling: ChildNode | null;
+    previousSibling: ChildNode | null;
+    parentNode: Node & ParentNode | null;
+    parentElement: HTMLElement | null;
+    childElementCount: number;
+    firstElementChild: Element | null;
+    lastElementChild: Element | null;
+    nextElementSibling: Element | null;
+    previousElementSibling: Element | null;
+    children: HTMLCollection;
+    constructor();
+    getAttribute(name: string): string | null;
+    getAttributeNS(namespaceURI: string | null, localName: string): string | null;
+    setAttribute(name: string, value: string): void;
+    setAttributeNS(namespaceURI: string | null, qualifiedName: string, value: string): void;
+    removeAttributeNS(namespaceURI: string | null, localName: string): void;
+    hasAttribute(name: string): boolean;
+    hasAttributeNS(namespaceURI: string | null, localName: string): boolean;
+    getBoundingClientRect(): DOMRect;
+    getClientRects(): DOMRectList;
+    getElementsByClassName(classNames: string): HTMLCollectionOf<Element>;
+    getElementsByTagName(qualifiedName: string): HTMLCollectionOf<Element>;
+    getElementsByTagNameNS(namespaceURI: string | null, localName: string): HTMLCollectionOf<Element>;
+    querySelector(selectors: string): Element | null;
+    querySelectorAll(selectors: string): NodeListOf<Element>;
+    matches(selectors: string): boolean;
+    closest(selectors: string): Element | null;
+    contains(other: Node | null): boolean;
+    append(...nodes: (Node | string)[]): void;
+    prepend(...nodes: (Node | string)[]): void;
+    after(...nodes: (Node | string)[]): void;
+    before(...nodes: (Node | string)[]): void;
+    replaceWith(...nodes: (Node | string)[]): void;
+    remove(): void;
+    insertAdjacentElement(where: InsertPosition, element: Element): Element | null;
+    insertAdjacentText(where: InsertPosition, data: string): void;
+    insertAdjacentHTML(position: InsertPosition, text: string): void;
+    replaceChildren(...nodes: (Node | string)[]): void;
+}

package/dist/dom/interfaces/svg.js

@@ -0,0 +1,161 @@
+export class SVGElement {
+    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) { }
+}

package/dist/dom/setup.d.ts

@@ -0,0 +1,9 @@
+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;