recker 1.0.27 → 1.0.28-next.3bf98c7

package/dist/seo/rules/images.js

@@ -0,0 +1,180 @@
+import { createResult } from './types.js';
+import { SEO_THRESHOLDS } from './thresholds.js';
+export const imageRules = [
+    {
+        id: 'images-alt-text',
+        name: 'Image Alt Text',
+        category: 'images',
+        severity: 'error',
+        description: 'All images must have alt text',
+        check: (ctx) => {
+            if (ctx.totalImages === undefined || ctx.totalImages === 0)
+                return null;
+            const withoutAlt = ctx.imagesWithoutAlt ?? 0;
+            if (withoutAlt > 0) {
+                const percentage = Math.round((withoutAlt / ctx.totalImages) * 100);
+                const severity = withoutAlt > ctx.totalImages / 2 ? 'fail' : 'warn';
+                return createResult({ id: 'images-alt-text', name: 'Image Alt Text', category: 'images', severity: 'error' }, severity, `${withoutAlt} of ${ctx.totalImages} images missing alt text (${percentage}%)`, { value: withoutAlt, recommendation: 'Add descriptive alt text to all images' });
+            }
+            return createResult({ id: 'images-alt-text', name: 'Image Alt Text', category: 'images', severity: 'error' }, 'pass', 'All images have alt text');
+        },
+    },
+    {
+        id: 'images-dimensions',
+        name: 'Image Dimensions',
+        category: 'images',
+        severity: 'warning',
+        description: 'Images should have width and height attributes to prevent CLS',
+        check: (ctx) => {
+            if (ctx.totalImages === undefined || ctx.totalImages === 0)
+                return null;
+            const missing = ctx.imagesMissingDimensions ?? 0;
+            if (missing > 0) {
+                return createResult({ id: 'images-dimensions', name: 'Image Dimensions', category: 'images', severity: 'warning' }, 'warn', `${missing} images missing width/height attributes`, { value: missing, recommendation: 'Add width and height to prevent layout shifts (CLS)' });
+            }
+            return createResult({ id: 'images-dimensions', name: 'Image Dimensions', category: 'images', severity: 'warning' }, 'pass', 'All images have dimensions defined');
+        },
+    },
+    {
+        id: 'images-lazy-loading',
+        name: 'Lazy Loading',
+        category: 'images',
+        severity: 'info',
+        description: 'Below-the-fold images should use lazy loading',
+        check: (ctx) => {
+            if (ctx.totalImages === undefined || ctx.totalImages <= 3)
+                return null;
+            const lazy = ctx.imagesWithLazyLoad ?? 0;
+            if (lazy === 0) {
+                return createResult({ id: 'images-lazy-loading', name: 'Lazy Loading', category: 'images', severity: 'info' }, 'info', 'No images use lazy loading', { recommendation: 'Add loading="lazy" to below-the-fold images' });
+            }
+            return createResult({ id: 'images-lazy-loading', name: 'Lazy Loading', category: 'images', severity: 'info' }, 'pass', `${lazy} images use lazy loading`);
+        },
+    },
+    {
+        id: 'images-format-modern',
+        name: 'Modern Image Formats',
+        category: 'images',
+        severity: 'info',
+        description: 'Images should use modern formats like WebP or AVIF',
+        check: (ctx) => {
+            if (ctx.totalImages === undefined || ctx.totalImages === 0)
+                return null;
+            const modern = ctx.imagesUsingModernFormats ?? 0;
+            if (ctx.totalImages > 0 && modern === 0) {
+                return createResult({ id: 'images-format-modern', name: 'Modern Image Formats', category: 'images', severity: 'info' }, 'info', 'No images using modern formats (WebP/AVIF)', { value: modern, recommendation: 'Serve images in WebP or AVIF format for better compression' });
+            }
+            return createResult({ id: 'images-format-modern', name: 'Modern Image Formats', category: 'images', severity: 'info' }, 'pass', `${modern} images using modern formats`, { value: modern });
+        },
+    },
+    {
+        id: 'images-empty-alt',
+        name: 'Empty Alt Text',
+        category: 'images',
+        severity: 'info',
+        description: 'Images with empty alt="" are treated as decorative',
+        check: (ctx) => {
+            const emptyAlt = ctx.imagesWithEmptyAlt ?? 0;
+            if (emptyAlt > 0) {
+                return createResult({ id: 'images-empty-alt', name: 'Empty Alt Text', category: 'images', severity: 'info' }, 'info', `${emptyAlt} image(s) with empty alt="" (decorative)`, { value: emptyAlt, recommendation: 'Ensure these images are truly decorative' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'images-alt-length',
+        name: 'Alt Text Length',
+        category: 'images',
+        severity: 'warning',
+        description: 'Alt text should be descriptive (min 10, max 125 chars)',
+        check: (ctx) => {
+            if (!ctx.altTextLengths || ctx.altTextLengths.length === 0)
+                return null;
+            const { minLength, maxLength } = SEO_THRESHOLDS.images.alt;
+            let shortAlts = 0;
+            let longAlts = 0;
+            ctx.altTextLengths.forEach(len => {
+                if (len < minLength)
+                    shortAlts++;
+                if (len > maxLength)
+                    longAlts++;
+            });
+            if (shortAlts > 0) {
+                return createResult({ id: 'images-alt-length', name: 'Alt Text Length', category: 'images', severity: 'warning' }, 'warn', `${shortAlts} alt text(s) are too short (min: ${minLength} chars)`, { value: shortAlts, recommendation: `Make alt texts more descriptive, at least ${minLength} characters.` });
+            }
+            if (longAlts > 0) {
+                return createResult({ id: 'images-alt-length', name: 'Alt Text Length', category: 'images', severity: 'warning' }, 'warn', `${longAlts} alt text(s) are too long (max: ${maxLength} chars)`, { value: longAlts, recommendation: `Shorten alt texts to be concise, under ${maxLength} characters.` });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'images-alt-length',
+        name: 'Alt Text Length',
+        category: 'images',
+        severity: 'warning',
+        description: 'Alt text should be descriptive (ideal 80-120, max 150 chars)',
+        check: (ctx) => {
+            if (!ctx.altTextLengths || ctx.altTextLengths.length === 0)
+                return null;
+            const { minLength, idealLength, maxLength } = SEO_THRESHOLDS.images.alt;
+            let shortAlts = 0;
+            let longAlts = 0;
+            let nonIdealAlts = 0;
+            ctx.altTextLengths.forEach(len => {
+                if (len < minLength)
+                    shortAlts++;
+                else if (len > maxLength)
+                    longAlts++;
+                else if (len < idealLength.min || len > idealLength.max)
+                    nonIdealAlts++;
+            });
+            if (shortAlts > 0) {
+                return createResult({ id: 'images-alt-length', name: 'Alt Text Length', category: 'images', severity: 'warning' }, 'warn', `${shortAlts} alt text(s) are too short (min: ${minLength} chars)`, { value: shortAlts, recommendation: `Make alt texts more descriptive, at least ${minLength} characters.` });
+            }
+            if (longAlts > 0) {
+                return createResult({ id: 'images-alt-length', name: 'Alt Text Length', category: 'images', severity: 'warning' }, 'warn', `${longAlts} alt text(s) are too long (max: ${maxLength} chars)`, { value: longAlts, recommendation: `Shorten alt texts to be concise, under ${maxLength} characters.` });
+            }
+            if (nonIdealAlts > 0) {
+                return createResult({ id: 'images-alt-length', name: 'Alt Text Length', category: 'images', severity: 'info' }, 'info', `${nonIdealAlts} alt text(s) are not in the ideal length range (${idealLength.min}-${idealLength.max} chars)`, { value: nonIdealAlts, recommendation: `Aim for alt texts between ${idealLength.min} and ${idealLength.max} characters for best results.` });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'images-clean-filenames',
+        name: 'Image Filenames',
+        category: 'images',
+        severity: 'info',
+        description: 'Image filenames should be descriptive and use keywords, not generic names.',
+        check: (ctx) => {
+            if (!ctx.imageFilenames || ctx.imageFilenames.length === 0)
+                return null;
+            const genericFilenames = ctx.imageFilenames.filter(name => /^(img|image|photo|pic)\d*\.(jpg|jpeg|png|webp|avif|gif)$/i.test(name) ||
+                /^screenshot_\d*\.(jpg|jpeg|png)$/i.test(name) ||
+                /^untitled-\d*\.(jpg|jpeg|png)$/i.test(name));
+            if (genericFilenames.length > 0) {
+                return createResult({ id: 'images-clean-filenames', name: 'Image Filenames', category: 'images', severity: 'warning' }, 'warn', `${genericFilenames.length} image(s) have generic filenames (e.g., IMG_1234.jpg)`, { value: genericFilenames.length, recommendation: 'Rename image files to be descriptive and include keywords (e.g., open-graph-example.jpg).' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'images-decoding-async',
+        name: 'Image Decoding Async',
+        category: 'images',
+        severity: 'info',
+        description: 'Use decoding="async" for non-critical images to improve rendering performance.',
+        check: (ctx) => {
+            if (ctx.totalImages === undefined || ctx.totalImages === 0)
+                return null;
+            if (ctx.imagesWithAsyncDecoding === undefined)
+                return null;
+            const nonAsync = ctx.totalImages - ctx.imagesWithAsyncDecoding;
+            if (nonAsync > 0 && ctx.totalImages > 3) {
+                return createResult({ id: 'images-decoding-async', name: 'Image Decoding Async', category: 'images', severity: 'info' }, 'info', `${nonAsync} image(s) do not use decoding="async"`, { value: nonAsync, recommendation: 'Consider adding decoding="async" to non-critical images for performance benefits.' });
+            }
+            return null;
+        },
+    },
+];

package/dist/seo/rules/index.d.ts

@@ -0,0 +1,52 @@
+import { SeoRule, RuleCategory, RuleSeverity, RuleContext, RuleResult } from './types.js';
+export * from './types.js';
+export * from './thresholds.js';
+export declare const ALL_SEO_RULES: SeoRule[];
+export declare const SCORING_WEIGHTS: {
+    readonly severity: {
+        readonly error: {
+            readonly pass: 10;
+            readonly fail: -15;
+            readonly warn: -10;
+            readonly info: 0;
+        };
+        readonly warning: {
+            readonly pass: 5;
+            readonly fail: -8;
+            readonly warn: -5;
+            readonly info: 0;
+        };
+        readonly info: {
+            readonly pass: 2;
+            readonly fail: -3;
+            readonly warn: -2;
+            readonly info: 0;
+        };
+    };
+    readonly category: Record<RuleCategory, number>;
+};
+export declare function calculateWeightedScore(results: RuleResult[]): {
+    score: number;
+    maxPossible: number;
+    details: {
+        category: RuleCategory;
+        score: number;
+        weight: number;
+    }[];
+};
+export interface RulesEngineOptions {
+    categories?: RuleCategory[];
+    excludeCategories?: RuleCategory[];
+    rules?: string[];
+    excludeRules?: string[];
+    minSeverity?: RuleSeverity;
+}
+export declare class SeoRulesEngine {
+    private rules;
+    constructor(options?: RulesEngineOptions);
+    evaluate(context: RuleContext): RuleResult[];
+    getRules(): SeoRule[];
+    getRulesByCategory(category: RuleCategory): SeoRule[];
+    getCategories(): RuleCategory[];
+}
+export declare function createRulesEngine(options?: RulesEngineOptions): SeoRulesEngine;

package/dist/seo/rules/index.js

@@ -0,0 +1,143 @@
+import { metaRules } from './meta.js';
+import { structuralRules } from './structural.js';
+import { contentRules } from './content.js';
+import { imageRules } from './images.js';
+import { linkRules } from './links.js';
+import { performanceRules } from './performance.js';
+import { technicalRules } from './technical.js';
+import { securityRules } from './security.js';
+import { schemaRules } from './schema.js';
+import { accessibilityRules } from './accessibility.js';
+import { mobileRules } from './mobile.js';
+import { i18nRules } from './i18n.js';
+import { ecommerceRules } from './ecommerce.js';
+import { localRules } from './local.js';
+import { cwvRules } from './cwv.js';
+import { crawlRules } from './crawl.js';
+import { readabilityRules } from './readability.js';
+import { pwaRules } from './pwa.js';
+import { socialRules } from './social.js';
+import { internalLinkingRules } from './internal-linking.js';
+import { bestPracticesRules } from './best-practices.js';
+export * from './types.js';
+export * from './thresholds.js';
+export const ALL_SEO_RULES = [
+    ...metaRules,
+    ...structuralRules,
+    ...contentRules,
+    ...imageRules,
+    ...linkRules,
+    ...performanceRules,
+    ...technicalRules,
+    ...securityRules,
+    ...schemaRules,
+    ...accessibilityRules,
+    ...mobileRules,
+    ...i18nRules,
+    ...ecommerceRules,
+    ...localRules,
+    ...cwvRules,
+    ...crawlRules,
+    ...readabilityRules,
+    ...pwaRules,
+    ...socialRules,
+    ...internalLinkingRules,
+    ...bestPracticesRules,
+];
+export const SCORING_WEIGHTS = {
+    severity: {
+        error: { pass: 10, fail: -15, warn: -10, info: 0 },
+        warning: { pass: 5, fail: -8, warn: -5, info: 0 },
+        info: { pass: 2, fail: -3, warn: -2, info: 0 },
+    },
+    category: {
+        title: 1.5,
+        meta: 1.3,
+        og: 1.0,
+        twitter: 0.8,
+        headings: 1.2,
+        images: 1.0,
+        links: 1.1,
+        content: 1.2,
+        technical: 1.3,
+        security: 0.9,
+        mobile: 1.2,
+        'structured-data': 1.0,
+        performance: 1.4,
+        accessibility: 0.8,
+    },
+};
+export function calculateWeightedScore(results) {
+    const categoryScores = {};
+    for (const result of results) {
+        const severityWeight = SCORING_WEIGHTS.severity[result.severity];
+        const statusScore = severityWeight[result.status] ?? 0;
+        if (!categoryScores[result.category]) {
+            categoryScores[result.category] = { score: 0, count: 0 };
+        }
+        categoryScores[result.category].score += statusScore;
+        categoryScores[result.category].count++;
+    }
+    let totalScore = 0;
+    let totalWeight = 0;
+    const details = [];
+    for (const [cat, data] of Object.entries(categoryScores)) {
+        const category = cat;
+        const categoryWeight = SCORING_WEIGHTS.category[category] ?? 1;
+        const normalizedScore = data.count > 0 ? data.score / data.count : 0;
+        const weightedScore = normalizedScore * categoryWeight;
+        details.push({ category, score: normalizedScore, weight: categoryWeight });
+        totalScore += weightedScore;
+        totalWeight += categoryWeight;
+    }
+    const maxPossible = 100;
+    const baseScore = 70;
+    const adjustedScore = Math.max(0, Math.min(100, baseScore + totalScore));
+    return { score: Math.round(adjustedScore), maxPossible, details };
+}
+export class SeoRulesEngine {
+    rules;
+    constructor(options = {}) {
+        let rules = [...ALL_SEO_RULES];
+        if (options.categories?.length) {
+            rules = rules.filter((r) => options.categories.includes(r.category));
+        }
+        if (options.excludeCategories?.length) {
+            rules = rules.filter((r) => !options.excludeCategories.includes(r.category));
+        }
+        if (options.rules?.length) {
+            rules = rules.filter((r) => options.rules.includes(r.id));
+        }
+        if (options.excludeRules?.length) {
+            rules = rules.filter((r) => !options.excludeRules.includes(r.id));
+        }
+        if (options.minSeverity) {
+            const severityOrder = ['info', 'warning', 'error'];
+            const minIndex = severityOrder.indexOf(options.minSeverity);
+            rules = rules.filter((r) => severityOrder.indexOf(r.severity) >= minIndex);
+        }
+        this.rules = rules;
+    }
+    evaluate(context) {
+        const results = [];
+        for (const rule of this.rules) {
+            const result = rule.check(context);
+            if (result) {
+                results.push(result);
+            }
+        }
+        return results;
+    }
+    getRules() {
+        return [...this.rules];
+    }
+    getRulesByCategory(category) {
+        return this.rules.filter((r) => r.category === category);
+    }
+    getCategories() {
+        return [...new Set(this.rules.map((r) => r.category))];
+    }
+}
+export function createRulesEngine(options) {
+    return new SeoRulesEngine(options);
+}

package/dist/seo/rules/internal-linking.d.ts

@@ -0,0 +1,2 @@
+import { SeoRule } from './types.js';
+export declare const internalLinkingRules: SeoRule[];