recker 1.0.32 → 1.0.33-next.bbc56eb

package/dist/seo/rules/links.js

@@ -1,5 +1,33 @@
 import { createResult } from './types.js';
 import { SEO_THRESHOLDS } from './thresholds.js';
+const GENERIC_ANCHOR_TEXTS = new Set([
+    'click here', 'click', 'here', 'read more', 'learn more', 'more', 'link',
+    'this', 'go', 'continue', 'next', 'previous', 'back', 'see more',
+    'find out more', 'discover more', 'view more', 'show more', 'details',
+    'clique aqui', 'clique', 'aqui', 'saiba mais', 'leia mais', 'veja mais',
+    'mais', 'confira', 'ver mais', 'continuar', 'próximo', 'anterior', 'voltar',
+    'haga clic aquí', 'clic aquí', 'aquí', 'leer más', 'ver más', 'más',
+    'saber más', 'descubrir más', 'continuar',
+    'cliquez ici', 'ici', 'en savoir plus', 'lire la suite', 'voir plus',
+    'plus', 'continuer', 'suivant', 'précédent',
+    'hier klicken', 'hier', 'mehr erfahren', 'weiterlesen', 'mehr',
+    'weiter', 'zurück',
+    'clicca qui', 'qui', 'scopri di più', 'leggi di più', 'continua',
+]);
+function isGenericAnchorText(text) {
+    const normalized = text.trim().toLowerCase();
+    if (normalized.length === 0)
+        return true;
+    if (normalized.length < 3)
+        return true;
+    if (GENERIC_ANCHOR_TEXTS.has(normalized))
+        return true;
+    if (/^[\d\s\-_.,!?#@%&*()[\]{}|\\/<>:;"'`~+=]+$/.test(normalized))
+        return true;
+    if (['link', 'url', 'page', 'site', 'website', 'info'].includes(normalized))
+        return true;
+    return false;
+}
 export const linkRules = [
     {
         id: 'links-descriptive-text',
@@ -147,4 +175,297 @@ export const linkRules = [
             return null;
         },
     },
+    {
+        id: 'links-anchor-text-non-descriptive',
+        name: 'Non-Descriptive Anchor Text',
+        category: 'links',
+        severity: 'warning',
+        description: 'Anchor text should describe the link destination',
+        check: (ctx) => {
+            if (!ctx.allLinks || ctx.allLinks.length === 0)
+                return null;
+            const nonDescriptive = ctx.allLinks.filter((link) => link.text && isGenericAnchorText(link.text));
+            if (nonDescriptive.length > 0) {
+                return createResult({ id: 'links-anchor-text-non-descriptive', name: 'Non-Descriptive Anchor Text', category: 'links', severity: 'warning' }, 'warn', `${nonDescriptive.length} link(s) with non-descriptive anchor text`, {
+                    value: nonDescriptive.length,
+                    recommendation: 'Replace generic text with descriptive anchors',
+                    evidence: {
+                        found: nonDescriptive.slice(0, 5).map((l) => `"${l.text}" → ${l.href}`),
+                        issue: 'Generic anchor text like "click here" provides no context',
+                        example: 'Instead of <a href="/pricing">Click here</a>, use <a href="/pricing">View our pricing plans</a>',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'links-self-referencing',
+        name: 'Self-Referencing Links',
+        category: 'links',
+        severity: 'info',
+        description: 'Pages should not link to themselves excessively',
+        check: (ctx) => {
+            if (!ctx.selfReferencingLinks)
+                return null;
+            if (ctx.selfReferencingLinks > 3) {
+                return createResult({ id: 'links-self-referencing', name: 'Self-Referencing Links', category: 'links', severity: 'info' }, 'info', `${ctx.selfReferencingLinks} self-referencing link(s)`, {
+                    value: ctx.selfReferencingLinks,
+                    recommendation: 'Remove unnecessary self-referencing links',
+                    evidence: {
+                        impact: 'Self-links can confuse users and dilute link equity',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'links-broken-internal',
+        name: 'Broken Internal Links',
+        category: 'links',
+        severity: 'error',
+        description: 'Internal links should not return 4xx errors',
+        check: (ctx) => {
+            if (!ctx.brokenInternalLinks || ctx.brokenInternalLinks.length === 0)
+                return null;
+            return createResult({ id: 'links-broken-internal', name: 'Broken Internal Links', category: 'links', severity: 'error' }, 'fail', `${ctx.brokenInternalLinks.length} broken internal link(s)`, {
+                value: ctx.brokenInternalLinks.length,
+                recommendation: 'Fix or remove broken internal links',
+                evidence: {
+                    found: ctx.brokenInternalLinks.slice(0, 10),
+                    impact: 'Broken links harm user experience and waste crawl budget',
+                },
+            });
+        },
+    },
+    {
+        id: 'links-broken-external',
+        name: 'Broken External Links',
+        category: 'links',
+        severity: 'warning',
+        description: 'External links should not return 4xx errors',
+        check: (ctx) => {
+            if (!ctx.brokenExternalLinks || ctx.brokenExternalLinks.length === 0)
+                return null;
+            return createResult({ id: 'links-broken-external', name: 'Broken External Links', category: 'links', severity: 'warning' }, 'warn', `${ctx.brokenExternalLinks.length} broken external link(s)`, {
+                value: ctx.brokenExternalLinks.length,
+                recommendation: 'Update or remove broken external links',
+                evidence: {
+                    found: ctx.brokenExternalLinks.slice(0, 10),
+                    impact: 'Broken external links reduce trust and user experience',
+                },
+            });
+        },
+    },
+    {
+        id: 'links-redirect-chains',
+        name: 'Redirect Chain Links',
+        category: 'links',
+        severity: 'warning',
+        description: 'Internal links should not point to redirect chains',
+        check: (ctx) => {
+            if (!ctx.redirectChainLinks || ctx.redirectChainLinks.length === 0)
+                return null;
+            return createResult({ id: 'links-redirect-chains', name: 'Redirect Chain Links', category: 'links', severity: 'warning' }, 'warn', `${ctx.redirectChainLinks.length} link(s) with redirect chains`, {
+                value: ctx.redirectChainLinks.length,
+                recommendation: 'Update links to point directly to final destination',
+                evidence: {
+                    found: ctx.redirectChainLinks.slice(0, 5).map((l) => `${l.from} → ${l.to} (${l.hops} hops)`),
+                    impact: 'Redirect chains slow page load and waste crawl budget',
+                },
+            });
+        },
+    },
+    {
+        id: 'links-few-internal',
+        name: 'Pages with Few Internal Links',
+        category: 'links',
+        severity: 'warning',
+        description: 'Pages should have at least 3 internal links',
+        check: (ctx) => {
+            if (ctx.internalLinks === undefined)
+                return null;
+            if (ctx.internalLinks < 3) {
+                return createResult({ id: 'links-few-internal', name: 'Pages with Few Internal Links', category: 'links', severity: 'warning' }, 'warn', `Only ${ctx.internalLinks} internal link(s)`, {
+                    value: ctx.internalLinks,
+                    recommendation: 'Add more internal links to improve site navigation',
+                    evidence: {
+                        found: ctx.internalLinks,
+                        expected: '3 or more internal links',
+                        impact: 'Few internal links isolate pages and hurt discoverability',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'links-orphan-page',
+        name: 'Orphan Page Detection',
+        category: 'links',
+        severity: 'warning',
+        description: 'Pages should have incoming internal links',
+        check: (ctx) => {
+            if (ctx.incomingInternalLinks === undefined)
+                return null;
+            if (ctx.isStartPage)
+                return null;
+            if (ctx.incomingInternalLinks === 0) {
+                return createResult({ id: 'links-orphan-page', name: 'Orphan Page Detection', category: 'links', severity: 'warning' }, 'warn', 'Page has no incoming internal links (orphan)', {
+                    value: 0,
+                    recommendation: 'Add internal links pointing to this page',
+                    evidence: {
+                        impact: 'Orphan pages are hard to discover and may not be indexed',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'links-click-depth',
+        name: 'Page Click Depth',
+        category: 'links',
+        severity: 'warning',
+        description: 'Important pages should be within 3 clicks from homepage',
+        check: (ctx) => {
+            if (ctx.clickDepth === undefined)
+                return null;
+            if (ctx.clickDepth > 3) {
+                return createResult({ id: 'links-click-depth', name: 'Page Click Depth', category: 'links', severity: 'warning' }, 'warn', `Page is ${ctx.clickDepth} clicks from homepage`, {
+                    value: ctx.clickDepth,
+                    recommendation: 'Improve site structure to keep pages within 3 clicks',
+                    evidence: {
+                        found: `${ctx.clickDepth} clicks`,
+                        expected: '3 clicks or less',
+                        impact: 'Deep pages are harder to discover and get less link equity',
+                    },
+                });
+            }
+            return createResult({ id: 'links-click-depth', name: 'Page Click Depth', category: 'links', severity: 'warning' }, 'pass', `Page is ${ctx.clickDepth} click(s) from homepage`, { value: ctx.clickDepth });
+        },
+    },
+    {
+        id: 'links-external-ratio',
+        name: 'External to Internal Link Ratio',
+        category: 'links',
+        severity: 'info',
+        description: 'Pages should have more internal than external links',
+        check: (ctx) => {
+            if (ctx.internalLinks === undefined || ctx.externalLinks === undefined)
+                return null;
+            if (ctx.totalLinks === undefined || ctx.totalLinks === 0)
+                return null;
+            const externalRatio = (ctx.externalLinks / ctx.totalLinks) * 100;
+            if (externalRatio > 70) {
+                return createResult({ id: 'links-external-ratio', name: 'External to Internal Link Ratio', category: 'links', severity: 'info' }, 'info', `High external link ratio (${Math.round(externalRatio)}%)`, {
+                    value: Math.round(externalRatio),
+                    recommendation: 'Add more internal links to balance link distribution',
+                    evidence: {
+                        found: `${ctx.externalLinks} external / ${ctx.internalLinks} internal`,
+                        expected: 'More internal than external links',
+                        impact: 'High external ratio may leak PageRank',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'links-nofollow-internal',
+        name: 'Internal Nofollow Links',
+        category: 'links',
+        severity: 'info',
+        description: 'Internal links with nofollow prevent PageRank flow',
+        check: (ctx) => {
+            if (!ctx.nofollowInternalLinks || ctx.nofollowInternalLinks === 0)
+                return null;
+            return createResult({ id: 'links-nofollow-internal', name: 'Internal Nofollow Links', category: 'links', severity: 'info' }, 'info', `${ctx.nofollowInternalLinks} internal link(s) with nofollow`, {
+                value: ctx.nofollowInternalLinks,
+                recommendation: 'Remove nofollow from internal links unless intentional',
+                evidence: {
+                    impact: 'Nofollow internal links waste PageRank',
+                },
+            });
+        },
+    },
+    {
+        id: 'excessive-links',
+        name: 'Excessive Links on Page',
+        category: 'links',
+        severity: 'warning',
+        description: 'Pages should not have more than 3,000 links',
+        check: (ctx) => {
+            if (ctx.totalLinks === undefined)
+                return null;
+            if (ctx.totalLinks > 3000) {
+                return createResult({ id: 'excessive-links', name: 'Excessive Links on Page', category: 'links', severity: 'warning' }, 'fail', `Page has ${ctx.totalLinks} links (exceeds 3,000 limit)`, {
+                    value: ctx.totalLinks,
+                    recommendation: 'Reduce the number of links to improve crawlability and page quality',
+                    evidence: {
+                        found: ctx.totalLinks,
+                        expected: '<3,000 links',
+                        impact: 'Search engines may consider pages with too many links as low-quality or spammy'
+                    }
+                });
+            }
+            if (ctx.totalLinks > 1000) {
+                return createResult({ id: 'excessive-links', name: 'Excessive Links on Page', category: 'links', severity: 'warning' }, 'warn', `Page has ${ctx.totalLinks} links (consider reducing)`, {
+                    value: ctx.totalLinks,
+                    recommendation: 'Review and remove unnecessary links',
+                    evidence: {
+                        found: ctx.totalLinks,
+                        expected: '<1,000 links recommended',
+                        impact: 'Many links dilute page authority and can slow page load'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'links-to-resources',
+        name: 'Links to Resources',
+        category: 'links',
+        severity: 'info',
+        description: 'Links should point to pages, not raw resources like images',
+        check: (ctx) => {
+            if (ctx.linksToResources === undefined)
+                return null;
+            if (ctx.linksToResources > 0) {
+                return createResult({ id: 'links-to-resources', name: 'Links to Resources', category: 'links', severity: 'info' }, 'info', `${ctx.linksToResources} links point directly to resources (images, PDFs)`, {
+                    value: ctx.linksToResources,
+                    recommendation: 'Use appropriate tags (<img>, <embed>) instead of <a> for resources',
+                    evidence: {
+                        found: ctx.resourceLinkUrls?.slice(0, 5) || [],
+                        impact: 'Links to raw resources may confuse crawlers about site architecture'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'links-403-forbidden',
+        name: '403 Forbidden Links',
+        category: 'links',
+        severity: 'warning',
+        description: 'External links should not return 403 Forbidden',
+        check: (ctx) => {
+            if (ctx.forbidden403Links === undefined)
+                return null;
+            if (ctx.forbidden403Links > 0) {
+                return createResult({ id: 'links-403-forbidden', name: '403 Forbidden Links', category: 'links', severity: 'warning' }, 'warn', `${ctx.forbidden403Links} external links return 403 Forbidden`, {
+                    value: ctx.forbidden403Links,
+                    recommendation: 'Replace or remove links that return 403 errors',
+                    evidence: {
+                        found: ctx.forbidden403LinkUrls?.slice(0, 5) || [],
+                        impact: 'Forbidden links negatively affect user experience'
+                    }
+                });
+            }
+            return null;
+        },
+    },
 ];

package/dist/seo/rules/meta.js

@@ -520,4 +520,28 @@ export const metaRules = [
             return null;
         },
     },
+    {
+        id: 'title-too-short',
+        name: 'Title Too Short',
+        category: 'title',
+        severity: 'warning',
+        description: 'Title should have at least 10 characters for SEO value',
+        check: (ctx) => {
+            if (!ctx.title)
+                return null;
+            const len = ctx.titleLength ?? ctx.title.length;
+            if (len <= 10) {
+                return createResult({ id: 'title-too-short', name: 'Title Too Short', category: 'title', severity: 'warning' }, 'warn', `Title is very short (${len} chars)`, {
+                    value: len,
+                    recommendation: 'Add more descriptive text to your title (50-60 chars ideal)',
+                    evidence: {
+                        found: `${len} characters`,
+                        expected: 'At least 10 characters, ideally 50-60',
+                        impact: 'Short titles do not provide enough information about the page and limit keyword potential'
+                    }
+                });
+            }
+            return null;
+        },
+    },
 ];

package/dist/seo/rules/mobile.js

@@ -48,24 +48,4 @@ export const mobileRules = [
             return createResult({ id: 'viewport-scalable', name: 'Viewport Scalable', category: 'mobile', severity: 'warning' }, 'pass', 'Viewport allows user scaling');
         },
     },
-    {
-        id: 'mobile-font-size',
-        name: 'Mobile Font Size',
-        category: 'mobile',
-        severity: 'info',
-        description: 'Content should use readable font sizes on mobile (at least 16px base)',
-        check: (ctx) => {
-            return createResult({ id: 'mobile-font-size', name: 'Mobile Font Size', category: 'mobile', severity: 'info' }, 'info', 'Font size check requires CSS analysis', { recommendation: 'Use a minimum base font size of 16px for mobile readability' });
-        },
-    },
-    {
-        id: 'mobile-tap-targets',
-        name: 'Mobile Tap Targets',
-        category: 'mobile',
-        severity: 'info',
-        description: 'Interactive elements should be at least 48x48px for touch accessibility',
-        check: (ctx) => {
-            return createResult({ id: 'mobile-tap-targets', name: 'Mobile Tap Targets', category: 'mobile', severity: 'info' }, 'info', 'Tap target size check requires CSS analysis', { recommendation: 'Ensure buttons and links are at least 48x48px with 8px spacing for mobile usability' });
-        },
-    },
 ];

package/dist/seo/rules/performance.js

@@ -243,4 +243,128 @@ export const performanceRules = [
             return null;
         },
     },
+    {
+        id: 'browser-caching',
+        name: 'Browser Caching',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Static resources should have browser caching enabled',
+        check: (ctx) => {
+            if (ctx.resourcesWithoutCaching === undefined)
+                return null;
+            if (ctx.resourcesWithoutCaching > 0) {
+                return createResult({ id: 'browser-caching', name: 'Browser Caching', category: 'performance', severity: 'warning' }, 'warn', `${ctx.resourcesWithoutCaching} resources without cache headers`, {
+                    value: ctx.resourcesWithoutCaching,
+                    recommendation: 'Enable browser caching with Cache-Control or Expires headers',
+                    evidence: {
+                        found: `${ctx.resourcesWithoutCaching} uncached resources`,
+                        expected: 'All static resources should have cache headers',
+                        impact: 'Without caching, browsers download resources repeatedly, increasing load time',
+                        learnMore: 'https://web.dev/uses-long-cache-ttl/'
+                    }
+                });
+            }
+            return createResult({ id: 'browser-caching', name: 'Browser Caching', category: 'performance', severity: 'warning' }, 'pass', 'Resources have proper cache headers');
+        },
+    },
+    {
+        id: 'js-css-total-size',
+        name: 'JS/CSS Total Size',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Total JS and CSS size should not exceed 2MB',
+        check: (ctx) => {
+            const jsSize = ctx.jsTotalSize || 0;
+            const cssSize = ctx.cssTotalSize || 0;
+            const totalSize = jsSize + cssSize;
+            if (totalSize === 0)
+                return null;
+            const sizeMb = totalSize / (1024 * 1024);
+            if (sizeMb > 2) {
+                return createResult({ id: 'js-css-total-size', name: 'JS/CSS Total Size', category: 'performance', severity: 'warning' }, 'fail', `JS/CSS total ${sizeMb.toFixed(2)}MB exceeds 2MB limit`, {
+                    value: totalSize,
+                    recommendation: 'Reduce JS/CSS file sizes through minification and code splitting',
+                    evidence: {
+                        found: `${sizeMb.toFixed(2)}MB (JS: ${(jsSize / 1024).toFixed(0)}KB, CSS: ${(cssSize / 1024).toFixed(0)}KB)`,
+                        expected: '<2MB total',
+                        impact: 'Large JS/CSS files significantly increase page load time',
+                        learnMore: 'https://web.dev/total-byte-weight/'
+                    }
+                });
+            }
+            if (sizeMb > 1) {
+                return createResult({ id: 'js-css-total-size', name: 'JS/CSS Total Size', category: 'performance', severity: 'warning' }, 'warn', `JS/CSS total ${sizeMb.toFixed(2)}MB is large`, {
+                    value: totalSize,
+                    recommendation: 'Consider reducing JS/CSS bundle sizes',
+                    evidence: {
+                        found: `${sizeMb.toFixed(2)}MB`,
+                        expected: '<1MB recommended',
+                        impact: 'Large bundles increase load time, especially on mobile'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'excessive-js-css-files',
+        name: 'Excessive JS/CSS Files',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Pages should not load more than 100 JS/CSS files',
+        check: (ctx) => {
+            const jsCount = ctx.jsFilesCount || 0;
+            const cssCount = ctx.cssFilesCount || 0;
+            const totalFiles = jsCount + cssCount;
+            if (totalFiles === 0)
+                return null;
+            if (totalFiles > 100) {
+                return createResult({ id: 'excessive-js-css-files', name: 'Excessive JS/CSS Files', category: 'performance', severity: 'warning' }, 'fail', `Page loads ${totalFiles} JS/CSS files (exceeds 100)`, {
+                    value: totalFiles,
+                    recommendation: 'Combine files or use bundling to reduce HTTP requests',
+                    evidence: {
+                        found: `${totalFiles} files (JS: ${jsCount}, CSS: ${cssCount})`,
+                        expected: '<100 files',
+                        impact: 'Each file requires a separate HTTP request, increasing page load time'
+                    }
+                });
+            }
+            if (totalFiles > 50) {
+                return createResult({ id: 'excessive-js-css-files', name: 'Excessive JS/CSS Files', category: 'performance', severity: 'warning' }, 'warn', `Page loads ${totalFiles} JS/CSS files`, {
+                    value: totalFiles,
+                    recommendation: 'Consider bundling resources to reduce requests',
+                    evidence: {
+                        found: `${totalFiles} files`,
+                        expected: '<50 files recommended',
+                        impact: 'Many files increase connection overhead'
+                    }
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'unminified-resources',
+        name: 'Unminified Resources',
+        category: 'performance',
+        severity: 'warning',
+        description: 'JS and CSS files should be minified',
+        check: (ctx) => {
+            if (ctx.unminifiedResources === undefined)
+                return null;
+            if (ctx.unminifiedResources > 0) {
+                return createResult({ id: 'unminified-resources', name: 'Unminified Resources', category: 'performance', severity: 'warning' }, 'warn', `${ctx.unminifiedResources} unminified JS/CSS files detected`, {
+                    value: ctx.unminifiedResources,
+                    recommendation: 'Minify JavaScript and CSS files to reduce file size',
+                    evidence: {
+                        found: `${ctx.unminifiedResources} unminified files`,
+                        expected: 'All JS/CSS files should be minified',
+                        impact: 'Minification reduces file size by removing whitespace and comments',
+                        learnMore: 'https://web.dev/minify-css/'
+                    }
+                });
+            }
+            return null;
+        },
+    },
 ];

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

@@ -0,0 +1,16 @@
+import { SeoRule } from './types.js';
+export declare const redirectRules: SeoRule[];
+declare module './types.js' {
+    interface RuleContext {
+        redirectChain?: Array<{
+            status: number;
+            from: string;
+            to: string;
+        }>;
+        wwwConsistency?: {
+            canonicalHasWww: boolean;
+            urlHasWww: boolean;
+            redirectsToCanonical: boolean;
+        };
+    }
+}