defuddle-cli 0.1.1 → 0.1.2

package/dist/index.js

@@ -8,6 +8,9 @@ import { readFile, writeFile } from 'fs/promises';
 import { fileURLToPath } from 'url';
 import { dirname, resolve } from 'path';
 import { createMarkdownContent } from './markdown.js';
+import { setupDOMInterfaces } from './dom/interfaces/setup.js';
+import { setupRange } from './dom/interfaces/range.js';
+import { setupDocumentMethods, setupWindowMethods } from './dom/interfaces/document.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
 // Define CSS interfaces globally first
@@ -302,352 +305,6 @@ globalThis.HTMLImageElement = class {
 };
 // Create a virtual console
 const virtualConsole = new VirtualConsole();
-// Function to set up DOM interfaces
-function setupDOMInterfaces(window) {
-    var _a;
-    try {
-        // First, set up basic window properties
-        try {
-            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 });
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set basic window properties:', error);
-        }
-        // Set up CSS interfaces
-        try {
-            if (!window.CSSRule) {
-                window.CSSRule = globalThis.CSSRule;
-            }
-            if (!window.CSSMediaRule) {
-                window.CSSMediaRule = globalThis.CSSMediaRule;
-            }
-            if (!window.CSSStyleSheet) {
-                window.CSSStyleSheet = globalThis.CSSStyleSheet;
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set CSS interfaces:', error);
-        }
-        // Set up HTML and SVG interfaces
-        try {
-            if (!window.HTMLImageElement) {
-                window.HTMLImageElement = globalThis.HTMLImageElement;
-            }
-            if (!window.SVGElement) {
-                window.SVGElement = globalThis.SVGElement;
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set HTML/SVG interfaces:', error);
-        }
-        // Set up screen object
-        try {
-            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
-                        }
-                    }
-                });
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set screen object:', error);
-        }
-        // Set up storage objects
-        try {
-            if (!window.localStorage) {
-                const storage = {
-                    length: 0,
-                    getItem: () => null,
-                    setItem: () => { },
-                    removeItem: () => { },
-                    clear: () => { },
-                    key: () => null
-                };
-                try {
-                    Object.defineProperty(window, 'localStorage', {
-                        value: storage,
-                        writable: false,
-                        configurable: false
-                    });
-                }
-                catch (error) {
-                    // Silently ignore storage setup failures
-                }
-            }
-            if (!window.sessionStorage) {
-                const storage = {
-                    length: 0,
-                    getItem: () => null,
-                    setItem: () => { },
-                    removeItem: () => { },
-                    clear: () => { },
-                    key: () => null
-                };
-                try {
-                    Object.defineProperty(window, 'sessionStorage', {
-                        value: storage,
-                        writable: false,
-                        configurable: false
-                    });
-                }
-                catch (error) {
-                    // Silently ignore storage setup failures
-                }
-            }
-        }
-        catch (error) {
-            // Silently ignore storage setup failures
-        }
-        // Set up animation frame methods
-        try {
-            if (!window.requestAnimationFrame) {
-                window.requestAnimationFrame = (callback) => {
-                    return setTimeout(callback, 0);
-                };
-            }
-            if (!window.cancelAnimationFrame) {
-                window.cancelAnimationFrame = (handle) => {
-                    clearTimeout(handle);
-                };
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set animation frame methods:', error);
-        }
-        // Set up DOM methods
-        try {
-            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;
-                };
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set getElementsByClassName:', error);
-        }
-        // Set up Node methods
-        try {
-            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;
-                };
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set Node.contains:', error);
-        }
-        // Set up Element methods
-        try {
-            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; }
-                    };
-                };
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set getBoundingClientRect:', error);
-        }
-        // Set up Document methods
-        try {
-            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;
-                };
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set getSelection:', error);
-        }
-        // Set up Window methods
-        try {
-            if (!window.Window.prototype.getComputedStyle) {
-                window.Window.prototype.getComputedStyle = function (elt, pseudoElt) {
-                    const style = {
-                        accentColor: '',
-                        alignContent: '',
-                        alignItems: '',
-                        alignSelf: '',
-                        getPropertyValue: function (prop) { return ''; }
-                    };
-                    return style;
-                };
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set getComputedStyle:', error);
-        }
-        // Set up Range constructor last
-        try {
-            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);
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set Range constructor:', error);
-        }
-        // Add HTMLAnchorElement to global scope
-        try {
-            if (!window.HTMLAnchorElement) {
-                window.HTMLAnchorElement = globalThis.HTMLAnchorElement;
-            }
-        }
-        catch (error) {
-            console.warn('Warning: Could not set HTMLAnchorElement:', error);
-        }
-    }
-    catch (error) {
-        console.error('Error in setupDOMInterfaces:', error);
-        // Don't throw the error, just log it
-    }
-}
 // Create a virtual DOM
 const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
     virtualConsole,
@@ -656,6 +313,9 @@ const dom = new JSDOM('<!DOCTYPE html><html><body></body></html>', {
     pretendToBeVisual: true,
     beforeParse(window) {
         setupDOMInterfaces(window);
+        setupRange(window);
+        setupDocumentMethods(window);
+        setupWindowMethods(window);
     }
 });
 // Get the window object
@@ -671,7 +331,14 @@ globalThis.NodeFilter = window.NodeFilter;
 globalThis.Range = window.Range;
 globalThis.DOMParser = window.DOMParser;
 globalThis.XMLSerializer = window.XMLSerializer;
-globalThis.navigator = window.navigator;
+// Handle navigator property
+if (!globalThis.navigator || Object.getOwnPropertyDescriptor(globalThis, 'navigator')?.configurable) {
+    Object.defineProperty(globalThis, 'navigator', {
+        value: window.navigator,
+        writable: false,
+        configurable: true
+    });
+}
 globalThis.HTMLElement = window.HTMLElement;
 // Define DOMSettableTokenList
 globalThis.DOMSettableTokenList = class {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "defuddle-cli",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "Command line interface for Defuddle - extract article content from web pages",
   "main": "dist/index.js",
   "bin": {

package/src/dom/interfaces/document.ts

@@ -0,0 +1,53 @@
+import { DOMWindow } from 'jsdom';
+import { SetupFunction } from './setup.js';
+
+export const setupDocumentMethods: SetupFunction = (window: DOMWindow) => {
+	if (!window.Document.prototype.getSelection) {
+		window.Document.prototype.getSelection = function(): Selection | null {
+			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: Node, allowPartialContainment: boolean = false): boolean {
+					return false;
+				},
+				removeRange: function(range: Range): void {}
+			} as unknown as Selection;
+			return selection;
+		};
+	}
+};
+
+export const setupWindowMethods: SetupFunction = (window: DOMWindow) => {
+	if (!window.Window.prototype.getComputedStyle) {
+		window.Window.prototype.getComputedStyle = function(elt: Element, pseudoElt?: string | null): CSSStyleDeclaration {
+			const style = {
+				accentColor: '',
+				alignContent: '',
+				alignItems: '',
+				alignSelf: '',
+				getPropertyValue: function(prop: string): string { return ''; }
+			} as CSSStyleDeclaration;
+			return style;
+		};
+	}
+}; 

package/src/dom/interfaces/range.ts

@@ -0,0 +1,120 @@
+import { DOMWindow } from 'jsdom';
+import { SetupFunction } from './setup.js';
+
+export const setupRange: SetupFunction = (window: DOMWindow) => {
+	if (!window.Range) {
+		window.Range = class Range {
+			static readonly START_TO_START = 0;
+			static readonly START_TO_END = 1;
+			static readonly END_TO_END = 2;
+			static readonly END_TO_START = 3;
+
+			readonly START_TO_START = 0;
+			readonly START_TO_END = 1;
+			readonly END_TO_END = 2;
+			readonly END_TO_START = 3;
+
+			startContainer: Node;
+			startOffset: number;
+			endContainer: Node;
+			endOffset: number;
+			collapsed: boolean;
+			commonAncestorContainer: Node;
+
+			constructor() {
+				this.startContainer = document.documentElement;
+				this.startOffset = 0;
+				this.endContainer = document.documentElement;
+				this.endOffset = 0;
+				this.collapsed = true;
+				this.commonAncestorContainer = document.documentElement;
+			}
+
+			createContextualFragment(fragment: string): DocumentFragment {
+				return document.createDocumentFragment();
+			}
+
+			detach(): void {}
+
+			cloneContents(): DocumentFragment {
+				return document.createDocumentFragment();
+			}
+
+			cloneRange(): Range {
+				return new Range();
+			}
+
+			collapse(toStart: boolean = false): void {}
+
+			compareBoundaryPoints(how: number, sourceRange: Range): number {
+				return 0;
+			}
+
+			comparePoint(node: Node, offset: number): number {
+				return 0;
+			}
+
+			deleteContents(): void {}
+
+			extractContents(): DocumentFragment {
+				return document.createDocumentFragment();
+			}
+
+			getBoundingClientRect(): DOMRect {
+				return {
+					top: 0,
+					left: 0,
+					bottom: 0,
+					right: 0,
+					width: 0,
+					height: 0,
+					x: 0,
+					y: 0,
+					toJSON: function() { return this; }
+				};
+			}
+
+			getClientRects(): DOMRectList {
+				return {
+					length: 0,
+					item: function() { return null; },
+					[Symbol.iterator]: function*() {}
+				} as DOMRectList;
+			}
+
+			insertNode(node: Node): void {}
+
+			intersectsNode(node: Node): boolean {
+				return false;
+			}
+
+			isPointInRange(node: Node, offset: number): boolean {
+				return false;
+			}
+
+			selectNode(node: Node): void {}
+
+			selectNodeContents(node: Node): void {
+				this.startContainer = node;
+				this.startOffset = 0;
+				this.endContainer = node;
+				this.endOffset = node.childNodes.length;
+				this.collapsed = false;
+			}
+
+			setEnd(node: Node, offset: number): void {}
+
+			setEndAfter(node: Node): void {}
+
+			setEndBefore(node: Node): void {}
+
+			setStart(node: Node, offset: number): void {}
+
+			setStartAfter(node: Node): void {}
+
+			setStartBefore(node: Node): void {}
+
+			surroundContents(newParent: Node): void {}
+		};
+	}
+};