defuddle-cli 0.1.1 → 0.1.2

package/README.md

@@ -5,7 +5,7 @@ Command line interface for [Defuddle](https://github.com/kepano/defuddle). Extra
 ## Installation
 
 ```bash
-npm install -g @defuddle/cli
+npm install -g defuddle/cli
 ```
 
 ## Usage

package/dist/cli.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/cli.js

@@ -0,0 +1,77 @@
+import { Command } from 'commander';
+import pkg from 'defuddle';
+const { Defuddle } = pkg;
+import { readFile } from 'fs/promises';
+import { resolve } from 'path';
+import { createVirtualDOM, setupDocumentProperties } from './dom/setup.js';
+const program = new Command();
+program
+    .name('defuddle-cli')
+    .description('CLI tool for parsing HTML content')
+    .version('1.0.0');
+program
+    .command('parse')
+    .description('Parse HTML content from a file or URL')
+    .argument('<source>', 'File path or URL to parse')
+    .option('-f, --format <format>', 'Output format (json, html, markdown)', 'json')
+    .option('-m, --markdown', 'Convert output to markdown', false)
+    .option('--md', 'Alias for --markdown', false)
+    .option('-d, --debug', 'Enable debug mode', false)
+    .action(async (source, options) => {
+    try {
+        // Handle --md alias
+        if (options.md) {
+            options.markdown = true;
+        }
+        let content;
+        let url;
+        // Determine if source is a URL or file path
+        if (source.startsWith('http://') || source.startsWith('https://')) {
+            url = source;
+            const response = await fetch(source);
+            content = await response.text();
+        }
+        else {
+            const filePath = resolve(process.cwd(), source);
+            content = await readFile(filePath, 'utf-8');
+        }
+        // Create virtual DOM instance
+        const dom = createVirtualDOM(content, url);
+        const doc = dom.window.document;
+        // Set up document properties
+        setupDocumentProperties(doc);
+        // Parse content
+        const defuddle = new Defuddle(doc);
+        const result = defuddle.parse();
+        // Format output based on options
+        let output;
+        if (options.markdown) {
+            output = result.content;
+        }
+        else {
+            switch (options.outputFormat) {
+                case 'html':
+                    output = result.content;
+                    break;
+                case 'markdown':
+                    output = result.content;
+                    break;
+                default:
+                    output = JSON.stringify(result, null, 2);
+            }
+        }
+        // Output result
+        console.log(output);
+        if (options.debug) {
+            console.error('\nDebug information:');
+            console.error('Source:', source);
+            console.error('Content length:', content.length);
+            console.error('Document structure:', doc.documentElement?.outerHTML);
+        }
+    }
+    catch (error) {
+        console.error('Error:', error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/commands/parse.d.ts

@@ -0,0 +1,8 @@
+export interface ParseOptions {
+    output?: string;
+    markdown?: boolean;
+    json?: boolean;
+    debug?: boolean;
+    property?: string;
+}
+export declare function handleParseCommand(source: string, options: ParseOptions): Promise<void>;

package/dist/commands/parse.js

@@ -0,0 +1,66 @@
+import pkg from 'defuddle';
+const { Defuddle } = pkg;
+import chalk from 'chalk';
+import { readFile, writeFile } from 'fs/promises';
+import { setupContentDOM, setupDocumentProperties } from '../dom/setup.js';
+import { createMarkdownContent } from '../markdown.js';
+export async function handleParseCommand(source, options) {
+    try {
+        // Load content from file or URL
+        let html;
+        if (source.startsWith('http')) {
+            const response = await fetch(source);
+            if (!response.ok) {
+                throw new Error(`Failed to fetch URL: ${response.statusText}`);
+            }
+            html = await response.text();
+        }
+        else {
+            html = await readFile(source, 'utf-8');
+        }
+        // Set up DOM environment
+        const dom = setupContentDOM(html, source);
+        const doc = dom.window.document;
+        // Set up document properties
+        setupDocumentProperties(doc);
+        // Parse content
+        const defuddle = new Defuddle(doc, { debug: options.debug });
+        const result = await defuddle.parse();
+        // Handle property extraction
+        if (options.property) {
+            const property = options.property.toLowerCase();
+            if (property in result) {
+                console.log(result[property]);
+                return;
+            }
+            throw new Error(`Property "${options.property}" not found in result`);
+        }
+        // If in debug mode, don't show content output
+        if (options.debug) {
+            process.exit(0);
+        }
+        // Handle output format
+        let output;
+        if (options.json) {
+            output = JSON.stringify(result, null, 2);
+        }
+        else if (options.markdown) {
+            output = createMarkdownContent(result.content, source);
+        }
+        else {
+            output = result.content;
+        }
+        // Write output to file or stdout
+        if (options.output) {
+            await writeFile(options.output, output);
+            console.log(chalk.green(`Output written to ${options.output}`));
+        }
+        else {
+            console.log(output);
+        }
+    }
+    catch (error) {
+        console.error(chalk.red('Error:'), error instanceof Error ? error.message : String(error));
+        process.exit(1);
+    }
+}

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

@@ -0,0 +1,38 @@
+export interface CSSRuleBase {
+    cssText: string;
+    parentRule: CSSRule | null;
+    parentStyleSheet: CSSStyleSheet | null;
+    type: number;
+}
+export interface CSSMediaRuleBase extends CSSRuleBase {
+    media: MediaList;
+    cssRules: CSSRuleList;
+    deleteRule(index: number): void;
+    insertRule(rule: string, index?: number): number;
+}
+export interface CSSStyleSheetBase {
+    cssRules: CSSRuleList;
+    ownerRule: CSSRule | null;
+    deleteRule(index: number): void;
+    insertRule(rule: string, index?: number): number;
+}
+export type CSSRule = CSSRuleBase;
+export type CSSMediaRule = CSSMediaRuleBase;
+export type CSSStyleSheet = CSSStyleSheetBase;
+export declare const CSSRuleConstants: {
+    readonly STYLE_RULE: 1;
+    readonly CHARSET_RULE: 2;
+    readonly IMPORT_RULE: 3;
+    readonly MEDIA_RULE: 4;
+    readonly FONT_FACE_RULE: 5;
+    readonly PAGE_RULE: 6;
+    readonly KEYFRAMES_RULE: 7;
+    readonly KEYFRAME_RULE: 8;
+    readonly NAMESPACE_RULE: 10;
+    readonly COUNTER_STYLE_RULE: 11;
+    readonly SUPPORTS_RULE: 12;
+    readonly DOCUMENT_RULE: 13;
+    readonly FONT_FEATURE_VALUES_RULE: 14;
+    readonly VIEWPORT_RULE: 15;
+    readonly REGION_STYLE_RULE: 16;
+};

package/dist/dom/interfaces/css.js

@@ -0,0 +1,20 @@
+// This file provides type definitions for CSS interfaces.
+// The actual implementations are provided by JSDOM.
+// Define static values
+export const CSSRuleConstants = {
+    STYLE_RULE: 1,
+    CHARSET_RULE: 2,
+    IMPORT_RULE: 3,
+    MEDIA_RULE: 4,
+    FONT_FACE_RULE: 5,
+    PAGE_RULE: 6,
+    KEYFRAMES_RULE: 7,
+    KEYFRAME_RULE: 8,
+    NAMESPACE_RULE: 10,
+    COUNTER_STYLE_RULE: 11,
+    SUPPORTS_RULE: 12,
+    DOCUMENT_RULE: 13,
+    FONT_FEATURE_VALUES_RULE: 14,
+    VIEWPORT_RULE: 15,
+    REGION_STYLE_RULE: 16
+};

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

@@ -0,0 +1,21 @@
+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 const setupCSSInterfaces: (global: any) => void;
+export declare const setupSVGElement: (global: any) => void;
+export declare function createMediaList(): MediaList;
+export declare function createCSSRuleList(): CSSRuleList;
+export declare function createCSSStyleDeclaration(): CSSStyleDeclaration;
+export declare function createNamedNodeMap(): NamedNodeMap;
+export declare function createNodeList(): NodeListOf<ChildNode>;
+export declare function createHTMLCollection(): HTMLCollection;
+export declare function createDOMSettableTokenList(): DOMSettableTokenList;

package/dist/dom/interfaces/global.js

@@ -0,0 +1,182 @@
+// Define CSS interfaces
+export const setupCSSInterfaces = (global) => {
+    global.CSSRule = class {
+        constructor(type) {
+            this.type = 1;
+            if (type !== undefined) {
+                Object.defineProperty(this, 'type', { value: type });
+            }
+            this.cssText = '';
+            this.parentRule = null;
+            this.parentStyleSheet = null;
+        }
+    };
+    // Static properties
+    Object.defineProperties(global.CSSRule, {
+        STYLE_RULE: { value: 1, writable: false },
+        CHARSET_RULE: { value: 2, writable: false },
+        IMPORT_RULE: { value: 3, writable: false },
+        MEDIA_RULE: { value: 4, writable: false },
+        FONT_FACE_RULE: { value: 5, writable: false },
+        PAGE_RULE: { value: 6, writable: false },
+        KEYFRAMES_RULE: { value: 7, writable: false },
+        KEYFRAME_RULE: { value: 8, writable: false },
+        NAMESPACE_RULE: { value: 10, writable: false },
+        COUNTER_STYLE_RULE: { value: 11, writable: false },
+        SUPPORTS_RULE: { value: 12, writable: false },
+        DOCUMENT_RULE: { value: 13, writable: false },
+        FONT_FEATURE_VALUES_RULE: { value: 14, writable: false },
+        VIEWPORT_RULE: { value: 15, writable: false },
+        REGION_STYLE_RULE: { value: 16, writable: false }
+    });
+    global.CSSMediaRule = class extends global.CSSRule {
+        constructor() {
+            super();
+            this.conditionText = '';
+            this.deleteRule = () => { };
+            this.insertRule = () => 0;
+            Object.defineProperty(this, 'type', { value: 4 });
+            this.media = createMediaList();
+            this.cssRules = createCSSRuleList();
+        }
+    };
+    global.CSSStyleSheet = class {
+        constructor() {
+            this.type = 'text/css';
+            this.href = null;
+            this.ownerNode = null;
+            this.parentStyleSheet = null;
+            this.title = null;
+            this.disabled = false;
+            this.ownerRule = null;
+            this.addRule = () => 0;
+            this.removeRule = () => { };
+            this.replace = async () => this;
+            this.replaceSync = () => { };
+            this.media = createMediaList();
+            this.cssRules = createCSSRuleList();
+            this.rules = this.cssRules;
+        }
+        insertRule(rule, index) {
+            return 0;
+        }
+        deleteRule(index) { }
+    };
+};
+// Define SVGElement
+export const setupSVGElement = (global) => {
+    global.SVGElement = class {
+        constructor() {
+            this.id = '';
+            this.className = '';
+            this.style = createCSSStyleDeclaration();
+            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 = createNamedNodeMap();
+            this.childNodes = createNodeList();
+            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 = createHTMLCollection();
+        }
+    };
+};
+// Helper functions
+export function createMediaList() {
+    return {
+        length: 0,
+        mediaText: '',
+        item: () => null,
+        appendMedium: () => { },
+        deleteMedium: () => { },
+        toString: () => '',
+        [Symbol.iterator]: function* () { yield ''; return undefined; }
+    };
+}
+export function createCSSRuleList() {
+    return {
+        length: 0,
+        item: () => null,
+        [Symbol.iterator]: function* () {
+            yield new globalThis.CSSRule();
+            return undefined;
+        }
+    };
+}
+export function createCSSStyleDeclaration() {
+    return {
+        cssText: '',
+        length: 0,
+        parentRule: null,
+        getPropertyPriority: () => '',
+        getPropertyValue: () => '',
+        item: () => '',
+        removeProperty: () => '',
+        setProperty: () => '',
+        [Symbol.iterator]: function* () { yield ''; return undefined; }
+    };
+}
+export function createNamedNodeMap() {
+    return {
+        length: 0,
+        getNamedItem: () => null,
+        getNamedItemNS: () => null,
+        item: () => null,
+        removeNamedItem: () => null,
+        removeNamedItemNS: () => null,
+        setNamedItem: () => null,
+        setNamedItemNS: () => null,
+        [Symbol.iterator]: function* () { yield null; return undefined; }
+    };
+}
+export function createNodeList() {
+    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; }
+    };
+}
+export function createHTMLCollection() {
+    return {
+        length: 0,
+        item: () => null,
+        namedItem: () => null,
+        [Symbol.iterator]: function* () { yield null; return undefined; }
+    };
+}
+export function createDOMSettableTokenList() {
+    return {
+        length: 0,
+        value: '',
+        add: () => { },
+        contains: () => false,
+        item: () => null,
+        remove: () => { },
+        replace: () => false,
+        supports: () => false,
+        toggle: () => false,
+        [Symbol.iterator]: function* () { yield ''; return undefined; }
+    };
+}

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

@@ -0,0 +1,57 @@
+export interface DOMSettableTokenList extends DOMTokenList {
+    value: string;
+}
+export interface HTMLElementBase extends Element {
+    style: CSSStyleDeclaration;
+    dataset: DOMStringMap;
+    title: string;
+    lang: string;
+    dir: string;
+    hidden: boolean;
+    tabIndex: number;
+}
+export interface HTMLImageElementBase extends HTMLElementBase {
+    alt: string;
+    src: string;
+    srcset: string;
+    sizes: string;
+    crossOrigin: string | null;
+    useMap: string;
+    isMap: boolean;
+    width: number;
+    height: number;
+    naturalWidth: number;
+    naturalHeight: number;
+    complete: boolean;
+    currentSrc: string;
+    decoding: 'sync' | 'async' | 'auto';
+    loading: 'eager' | 'lazy';
+    referrerPolicy: string;
+}
+export interface HTMLIFrameElementBase extends HTMLElementBase {
+    src: string;
+    srcdoc: string;
+    name: string;
+    sandbox: DOMSettableTokenList;
+    allow: string;
+    allowFullscreen: boolean;
+    width: string;
+    height: string;
+    contentDocument: Document | null;
+    contentWindow: Window | null;
+    referrerPolicy: string;
+}
+export type HTMLElement = HTMLElementBase;
+export type HTMLImageElement = HTMLImageElementBase;
+export type HTMLIFrameElement = HTMLIFrameElementBase;
+export type HTMLOListElement = HTMLElementBase;
+export type HTMLUListElement = HTMLElementBase;
+export type HTMLTableElement = HTMLElementBase;
+export type HTMLTableRowElement = HTMLElementBase;
+export type HTMLTableCellElement = HTMLElementBase;
+export type HTMLTableSectionElement = HTMLElementBase;
+export type HTMLTableCaptionElement = HTMLElementBase;
+export type HTMLButtonElement = HTMLElementBase;
+export type HTMLSpanElement = HTMLElementBase;
+export type HTMLDivElement = HTMLElementBase;
+export type HTMLAnchorElement = HTMLElementBase;

package/dist/dom/interfaces/html.js

@@ -0,0 +1,3 @@
+// This file provides type definitions for DOM interfaces.
+// The actual implementations are provided by JSDOM.
+export {};

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

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

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

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