recker 1.0.43 → 1.0.44

package/dist/scrape/parser/nodes/node.d.ts

@@ -0,0 +1,18 @@
+import NodeType from './type.js';
+import type HTMLElement from './html.js';
+export default abstract class Node {
+    parentNode: HTMLElement | null;
+    abstract rawTagName: string;
+    abstract nodeType: NodeType;
+    childNodes: Node[];
+    range: readonly [number, number];
+    abstract text: string;
+    abstract rawText: string;
+    abstract toString(): string;
+    abstract clone(): Node;
+    constructor(parentNode?: HTMLElement | null, range?: [number, number]);
+    remove(): this;
+    get innerText(): string;
+    get textContent(): string;
+    set textContent(val: string);
+}

package/dist/scrape/parser/nodes/node.js

@@ -0,0 +1,31 @@
+import he from 'he';
+export default class Node {
+    parentNode;
+    childNodes = [];
+    range = [-1, -1];
+    constructor(parentNode = null, range) {
+        this.parentNode = parentNode;
+        if (range) {
+            this.range = range;
+        }
+    }
+    remove() {
+        if (this.parentNode) {
+            const children = this.parentNode.childNodes;
+            this.parentNode.childNodes = children.filter((child) => {
+                return this !== child;
+            });
+            this.parentNode = null;
+        }
+        return this;
+    }
+    get innerText() {
+        return this.rawText;
+    }
+    get textContent() {
+        return he.decode(this.rawText);
+    }
+    set textContent(val) {
+        this.rawText = he.encode(val);
+    }
+}

package/dist/scrape/parser/nodes/text.d.ts

@@ -0,0 +1,14 @@
+import Node from './node.js';
+import NodeType from './type.js';
+export default class TextNode extends Node {
+    rawText: string;
+    nodeType: NodeType;
+    rawTagName: string;
+    constructor(rawText: string, parentNode?: any, range?: [number, number]);
+    clone(): Node;
+    get text(): string;
+    get trimmedText(): string;
+    get trimmedRawText(): string;
+    get isWhitespace(): boolean;
+    toString(): string;
+}

package/dist/scrape/parser/nodes/text.js

@@ -0,0 +1,30 @@
+import he from 'he';
+import Node from './node.js';
+import NodeType from './type.js';
+export default class TextNode extends Node {
+    rawText;
+    nodeType = NodeType.TEXT_NODE;
+    rawTagName = '#text';
+    constructor(rawText, parentNode = null, range) {
+        super(parentNode, range);
+        this.rawText = rawText;
+    }
+    clone() {
+        return new TextNode(this.rawText, null, this.range ? [...this.range] : undefined);
+    }
+    get text() {
+        return he.decode(this.rawText);
+    }
+    get trimmedText() {
+        return this.text.trim();
+    }
+    get trimmedRawText() {
+        return this.rawText.trim();
+    }
+    get isWhitespace() {
+        return /^(\s| )*$/.test(this.rawText);
+    }
+    toString() {
+        return this.rawText;
+    }
+}

package/dist/scrape/parser/nodes/type.d.ts

@@ -0,0 +1,6 @@
+declare enum NodeType {
+    ELEMENT_NODE = 1,
+    TEXT_NODE = 3,
+    COMMENT_NODE = 8
+}
+export default NodeType;

package/dist/scrape/parser/nodes/type.js

@@ -0,0 +1,7 @@
+var NodeType;
+(function (NodeType) {
+    NodeType[NodeType["ELEMENT_NODE"] = 1] = "ELEMENT_NODE";
+    NodeType[NodeType["TEXT_NODE"] = 3] = "TEXT_NODE";
+    NodeType[NodeType["COMMENT_NODE"] = 8] = "COMMENT_NODE";
+})(NodeType || (NodeType = {}));
+export default NodeType;

package/dist/scrape/parser/parse.d.ts

@@ -0,0 +1 @@
+export { parse as default } from './nodes/html.js';

package/dist/scrape/parser/parse.js

@@ -0,0 +1 @@
+export { parse as default } from './nodes/html.js';

package/dist/scrape/parser/valid.d.ts

@@ -0,0 +1,2 @@
+import { Options } from './nodes/html.js';
+export default function valid(data: string, options?: Partial<Options>): boolean;

package/dist/scrape/parser/valid.js

@@ -0,0 +1,5 @@
+import { base_parse } from './nodes/html.js';
+export default function valid(data, options = {}) {
+    const stack = base_parse(data, options);
+    return Boolean(stack.length === 1);
+}

package/dist/scrape/parser/void-tag.d.ts

@@ -0,0 +1,7 @@
+export default class VoidTag {
+    addClosingSlash: boolean;
+    private voidTags;
+    constructor(addClosingSlash?: boolean, tags?: string[]);
+    formatNode(tag: string, attrs: string, innerHTML: string): string;
+    isVoidElement(tag: string): boolean;
+}

package/dist/scrape/parser/void-tag.js

@@ -0,0 +1,43 @@
+export default class VoidTag {
+    addClosingSlash;
+    voidTags;
+    constructor(addClosingSlash = false, tags) {
+        this.addClosingSlash = addClosingSlash;
+        if (Array.isArray(tags)) {
+            this.voidTags = tags.reduce((set, tag) => {
+                return set.add(tag.toLowerCase()).add(tag.toUpperCase()).add(tag);
+            }, new Set());
+        }
+        else {
+            this.voidTags = [
+                'area',
+                'base',
+                'br',
+                'col',
+                'embed',
+                'hr',
+                'img',
+                'input',
+                'link',
+                'meta',
+                'param',
+                'source',
+                'track',
+                'wbr',
+            ].reduce((set, tag) => {
+                return set.add(tag.toLowerCase()).add(tag.toUpperCase()).add(tag);
+            }, new Set());
+        }
+    }
+    formatNode(tag, attrs, innerHTML) {
+        const addClosingSlash = this.addClosingSlash;
+        const closingSpace = addClosingSlash && attrs && !attrs.endsWith(' ') ? ' ' : '';
+        const closingSlash = addClosingSlash ? `${closingSpace}/` : '';
+        return this.isVoidElement(tag.toLowerCase())
+            ? `<${tag}${attrs}${closingSlash}>`
+            : `<${tag}${attrs}>${innerHTML}</${tag}>`;
+    }
+    isVoidElement(tag) {
+        return this.voidTags.has(tag);
+    }
+}

package/dist/scrape/spider.d.ts

@@ -24,6 +24,25 @@ export interface SpiderPageResult {
     links: ExtractedLink[];
     duration: number;
     error?: string;
+    meta?: {
+        description?: string;
+        keywords?: string[];
+        author?: string;
+        robots?: string[];
+        canonical?: string;
+        viewport?: string;
+        lang?: string;
+        charset?: string;
+    };
+    metrics?: {
+        htmlSize: number;
+        textLength: number;
+    };
+    social?: {
+        ogTitle?: string;
+        ogDescription?: string;
+        ogImage?: string;
+    };
 }
 export interface SpiderProgress {
     crawled: number;

package/dist/scrape/spider.js

@@ -375,6 +375,17 @@ export class Spider {
             const doc = await ScrapeDocument.create(html, { baseUrl: item.url });
             const title = doc.selectFirst('title').text() || '';
             const links = doc.links({ absolute: true });
+            const meta = doc.meta();
+            const og = doc.openGraph();
+            const metrics = {
+                htmlSize: html.length,
+                textLength: doc.text('body').length,
+            };
+            const social = {
+                ogTitle: og.title,
+                ogDescription: og.description,
+                ogImage: Array.isArray(og.image) ? og.image[0] : og.image,
+            };
             const result = {
                 url: item.url,
                 status,
@@ -382,6 +393,18 @@ export class Spider {
                 depth: item.depth,
                 links,
                 duration: Math.round(performance.now() - startTime),
+                meta: {
+                    description: meta.description,
+                    keywords: meta.keywords,
+                    author: meta.author,
+                    robots: meta.robots,
+                    canonical: meta.canonical,
+                    viewport: meta.viewport,
+                    charset: meta.charset,
+                    lang: doc.attr('html', 'lang')
+                },
+                metrics,
+                social
             };
             this.results.push(result);
             this.options.onPage?.(result);
@@ -400,17 +423,19 @@ export class Spider {
             }
         }
         catch (error) {
+            const status = error.status || error.statusCode || (error.response ? error.response.status : 0);
+            const message = error.message || 'Unknown error';
             const errorResult = {
                 url: item.url,
-                status: 0,
+                status: status,
                 title: '',
                 depth: item.depth,
                 links: [],
                 duration: Math.round(performance.now() - startTime),
-                error: error.message,
+                error: message,
             };
             this.results.push(errorResult);
-            this.errors.push({ url: item.url, error: error.message });
+            this.errors.push({ url: item.url, error: message });
             this.options.onPage?.(errorResult);
         }
     }

package/dist/scrape/types.d.ts

@@ -5,6 +5,11 @@ export interface ExtractedLink {
     target?: string;
     title?: string;
     type?: 'internal' | 'external' | 'anchor' | 'mailto' | 'tel';
+    hasImage?: boolean;
+    hasImageWithAlt?: boolean;
+    hasSvg?: boolean;
+    hasSvgWithTitle?: boolean;
+    ariaLabel?: string;
 }
 export interface ExtractedImage {
     src: string;
@@ -91,6 +96,8 @@ export type ExtractionSchemaField = string | {
     attribute?: string;
     multiple?: boolean;
     transform?: (value: string) => unknown;
+    default?: unknown;
+    optional?: boolean;
 };
 export interface ExtractionSchema {
     [key: string]: ExtractionSchemaField;

package/dist/seo/analyzer.d.ts

@@ -1,19 +1,23 @@
-import type { CheerioAPI } from 'cheerio';
+import { HTMLElement } from '../scrape/parser/index.js';
 import type { SeoReport, SeoAnalyzerOptions } from './types.js';
 import { type RulesEngineOptions } from './rules/index.js';
 export interface SeoAnalyzerFullOptions extends SeoAnalyzerOptions {
     rules?: RulesEngineOptions;
 }
 export declare class SeoAnalyzer {
-    private $;
+    private root;
     private options;
     private rulesEngine;
-    constructor($: CheerioAPI, options?: SeoAnalyzerFullOptions);
+    constructor(root: HTMLElement, options?: SeoAnalyzerFullOptions);
     static fromHtml(html: string, options?: SeoAnalyzerFullOptions): Promise<SeoAnalyzer>;
     analyze(): SeoReport;
+    private getMainBody;
+    private getVisibleText;
     private buildRuleContext;
     private analyzeUrlQuality;
     private analyzeJsRendering;
+    private analyzeResponsiveImages;
+    private analyzeInlineImages;
     private checkMixedContent;
     private analyzeLinkSecurity;
     private detectFavicon;
@@ -23,7 +27,12 @@ export declare class SeoAnalyzer {
     private analyzeStructuralHtml;
     private analyzeBreadcrumbs;
     private analyzeMultimedia;
+    private analyzeSocialLinks;
     private analyzeTrustSignals;
+    private analyzeAnalytics;
+    private analyzeFeeds;
+    private analyzeConversionElements;
+    private analyzeAdvancedImages;
     private calculateTextHtmlRatio;
     private convertToCheckResults;
     private buildSummary;
@@ -39,11 +48,12 @@ export declare class SeoAnalyzer {
     private buildImageAnalysis;
     private buildSocialAnalysis;
     private buildTechnicalAnalysis;
+    private analyzeResources;
     private calculateScore;
     getRules(): import("./rules/types.js").SeoRule[];
     getRulesByCategory(category: string): import("./rules/types.js").SeoRule[];
     getCategories(): import("./rules/types.js").RuleCategory[];
 }
 export declare function analyzeSeo(html: string, options?: SeoAnalyzerFullOptions): Promise<SeoReport>;
-export { SEO_THRESHOLDS, createRulesEngine, SeoRulesEngine } from './rules/index.js';
-export type { RuleContext, RuleResult, RulesEngineOptions, RuleCategory, RuleSeverity, SeoRule } from './rules/index.js';
+export { SEO_THRESHOLDS, createRulesEngine, SeoRulesEngine, } from './rules/index.js';
+export type { RuleContext, RuleResult, RulesEngineOptions, RuleCategory, RuleSeverity, SeoRule, } from './rules/index.js';