recker 1.0.28 → 1.0.29

package/dist/seo/rules/i18n.js

@@ -0,0 +1,222 @@
+import { createResult } from './types.js';
+export const i18nRules = [
+    {
+        id: 'i18n-hreflang-exists',
+        name: 'Hreflang Tags',
+        category: 'technical',
+        severity: 'warning',
+        description: 'Multi-language sites should have hreflang tags for proper language targeting',
+        check: (ctx) => {
+            if (!ctx.hreflangTags || ctx.hreflangTags.length === 0) {
+                if (ctx.hasLang && ctx.langValue && ctx.langValue !== 'en') {
+                    return createResult({ id: 'i18n-hreflang-exists', name: 'Hreflang Tags', category: 'technical', severity: 'warning' }, 'info', 'No hreflang tags found (recommended for multi-language sites)', {
+                        recommendation: 'Add hreflang tags to indicate language/region alternatives',
+                        evidence: {
+                            expected: '<link rel="alternate" hreflang="en" href="https://example.com/en/">',
+                            example: '<link rel="alternate" hreflang="en" href="https://example.com/en/">\n<link rel="alternate" hreflang="es" href="https://example.com/es/">\n<link rel="alternate" hreflang="x-default" href="https://example.com/">',
+                            impact: 'Without hreflang, search engines may show wrong language version to users in different countries',
+                            learnMore: 'https://developers.google.com/search/docs/specialty/international/localized-versions',
+                        },
+                    });
+                }
+                return null;
+            }
+            return createResult({ id: 'i18n-hreflang-exists', name: 'Hreflang Tags', category: 'technical', severity: 'warning' }, 'pass', `${ctx.hreflangTags.length} hreflang tag(s) found`, { value: ctx.hreflangTags.length });
+        },
+    },
+    {
+        id: 'i18n-hreflang-self',
+        name: 'Hreflang Self-Reference',
+        category: 'technical',
+        severity: 'warning',
+        description: 'Hreflang tags should include a self-referencing tag for the current page',
+        check: (ctx) => {
+            if (!ctx.hreflangTags || ctx.hreflangTags.length === 0)
+                return null;
+            if (!ctx.url)
+                return null;
+            const currentUrl = ctx.url.toLowerCase().replace(/\/$/, '');
+            const hasSelfRef = ctx.hreflangTags.some((tag) => {
+                const href = tag.href?.toLowerCase().replace(/\/$/, '');
+                return href === currentUrl;
+            });
+            if (!hasSelfRef) {
+                return createResult({ id: 'i18n-hreflang-self', name: 'Hreflang Self-Reference', category: 'technical', severity: 'warning' }, 'warn', 'Missing self-referencing hreflang tag', {
+                    recommendation: 'Add a hreflang tag that points to the current page',
+                    evidence: {
+                        found: `Current URL: ${ctx.url}`,
+                        expected: `<link rel="alternate" hreflang="${ctx.langValue || 'en'}" href="${ctx.url}">`,
+                        impact: 'Google recommends including a self-referencing hreflang tag for clarity',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'i18n-hreflang-x-default',
+        name: 'Hreflang X-Default',
+        category: 'technical',
+        severity: 'info',
+        description: 'Include x-default hreflang for users outside defined regions',
+        check: (ctx) => {
+            if (!ctx.hreflangTags || ctx.hreflangTags.length < 2)
+                return null;
+            const hasXDefault = ctx.hreflangTags.some((tag) => tag.lang === 'x-default');
+            if (!hasXDefault) {
+                return createResult({ id: 'i18n-hreflang-x-default', name: 'Hreflang X-Default', category: 'technical', severity: 'info' }, 'info', 'No x-default hreflang tag found', {
+                    recommendation: 'Add hreflang="x-default" to specify the fallback page for unmatched languages',
+                    evidence: {
+                        expected: '<link rel="alternate" hreflang="x-default" href="https://example.com/">',
+                        impact: 'Without x-default, users in unsupported regions may not see the best version',
+                    },
+                });
+            }
+            return createResult({ id: 'i18n-hreflang-x-default', name: 'Hreflang X-Default', category: 'technical', severity: 'info' }, 'pass', 'x-default hreflang tag present');
+        },
+    },
+    {
+        id: 'i18n-hreflang-valid-codes',
+        name: 'Hreflang Valid Codes',
+        category: 'technical',
+        severity: 'warning',
+        description: 'Hreflang language codes must be valid ISO 639-1 codes',
+        check: (ctx) => {
+            if (!ctx.hreflangTags || ctx.hreflangTags.length === 0)
+                return null;
+            const validLanguageCodes = new Set([
+                'aa', 'ab', 'af', 'ak', 'sq', 'am', 'ar', 'an', 'hy', 'as', 'av', 'ae', 'ay', 'az',
+                'ba', 'bm', 'eu', 'be', 'bn', 'bh', 'bi', 'bo', 'bs', 'br', 'bg', 'my', 'ca', 'cs',
+                'ch', 'ce', 'zh', 'cu', 'cv', 'kw', 'co', 'cr', 'cy', 'da', 'de', 'dv', 'nl', 'dz',
+                'en', 'eo', 'et', 'ee', 'fo', 'fa', 'fj', 'fi', 'fr', 'fy', 'ff', 'ka', 'el', 'gn',
+                'gu', 'ht', 'ha', 'he', 'hz', 'hi', 'ho', 'hr', 'hu', 'ig', 'is', 'io', 'ii', 'iu',
+                'ie', 'ia', 'id', 'ik', 'it', 'jv', 'ja', 'kl', 'kn', 'ks', 'kr', 'kk', 'km', 'ki',
+                'rw', 'ky', 'kv', 'kg', 'ko', 'kj', 'ku', 'lo', 'la', 'lv', 'li', 'ln', 'lt', 'lb',
+                'lu', 'lg', 'mk', 'mh', 'ml', 'mi', 'mr', 'ms', 'mg', 'mt', 'mn', 'na', 'nv', 'nr',
+                'nd', 'ng', 'ne', 'nn', 'nb', 'no', 'ny', 'oc', 'oj', 'or', 'om', 'os', 'pa', 'pi',
+                'pl', 'pt', 'ps', 'qu', 'rm', 'ro', 'rn', 'ru', 'sg', 'sa', 'si', 'sk', 'sl', 'se',
+                'sm', 'sn', 'sd', 'so', 'st', 'es', 'sc', 'sr', 'ss', 'su', 'sw', 'sv', 'ty', 'ta',
+                'tt', 'te', 'tg', 'tl', 'th', 'ti', 'to', 'tn', 'ts', 'tk', 'tr', 'tw', 'ug', 'uk',
+                'ur', 'uz', 've', 'vi', 'vo', 'wa', 'wo', 'xh', 'yi', 'yo', 'za', 'zu',
+                'x-default',
+            ]);
+            const invalidTags = [];
+            for (const tag of ctx.hreflangTags) {
+                const lang = tag.lang?.toLowerCase().split('-')[0];
+                if (lang && !validLanguageCodes.has(lang)) {
+                    invalidTags.push(tag.lang);
+                }
+            }
+            if (invalidTags.length > 0) {
+                return createResult({ id: 'i18n-hreflang-valid-codes', name: 'Hreflang Valid Codes', category: 'technical', severity: 'warning' }, 'warn', `Invalid hreflang codes: ${invalidTags.join(', ')}`, {
+                    recommendation: 'Use valid ISO 639-1 language codes',
+                    evidence: {
+                        found: invalidTags,
+                        expected: 'Valid ISO 639-1 codes like: en, es, fr, de, pt-BR, zh-CN',
+                        learnMore: 'https://en.wikipedia.org/wiki/List_of_ISO_639-1_codes',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'i18n-hreflang-return-links',
+        name: 'Hreflang Return Links',
+        category: 'technical',
+        severity: 'warning',
+        description: 'All hreflang URLs should return links back to this page (bidirectional)',
+        check: (ctx) => {
+            if (!ctx.hreflangTags || ctx.hreflangTags.length < 2)
+                return null;
+            return createResult({ id: 'i18n-hreflang-return-links', name: 'Hreflang Return Links', category: 'technical', severity: 'warning' }, 'info', 'Hreflang return links cannot be verified from HTML alone', {
+                recommendation: 'Ensure all alternate pages link back to this page with matching hreflang tags',
+                evidence: {
+                    impact: 'Missing return links can cause Google to ignore hreflang annotations',
+                    learnMore: 'https://developers.google.com/search/docs/specialty/international/localized-versions#bidirectional',
+                },
+            });
+        },
+    },
+    {
+        id: 'i18n-content-language',
+        name: 'Content-Language Header',
+        category: 'technical',
+        severity: 'info',
+        description: 'Content-Language header can indicate the language of the document',
+        check: (ctx) => {
+            if (!ctx.responseHeaders)
+                return null;
+            const contentLang = ctx.responseHeaders['content-language'] || ctx.responseHeaders['Content-Language'];
+            if (!contentLang) {
+                if (ctx.hasLang) {
+                    return createResult({ id: 'i18n-content-language', name: 'Content-Language Header', category: 'technical', severity: 'info' }, 'info', 'Content-Language header not set', {
+                        recommendation: `Consider adding Content-Language: ${ctx.langValue || 'en'} header`,
+                        evidence: {
+                            impact: 'While not critical for SEO, it helps with content negotiation',
+                        },
+                    });
+                }
+                return null;
+            }
+            if (ctx.langValue) {
+                const headerLang = Array.isArray(contentLang) ? contentLang[0] : contentLang;
+                const headerLangPrimary = headerLang.toLowerCase().split('-')[0].split(',')[0].trim();
+                const htmlLangPrimary = ctx.langValue.toLowerCase().split('-')[0];
+                if (headerLangPrimary !== htmlLangPrimary) {
+                    return createResult({ id: 'i18n-content-language', name: 'Content-Language Header', category: 'technical', severity: 'info' }, 'warn', `Content-Language (${headerLang}) doesn't match html lang (${ctx.langValue})`, {
+                        recommendation: 'Ensure Content-Language header matches the html lang attribute',
+                    });
+                }
+            }
+            return createResult({ id: 'i18n-content-language', name: 'Content-Language Header', category: 'technical', severity: 'info' }, 'pass', `Content-Language: ${contentLang}`);
+        },
+    },
+    {
+        id: 'i18n-lang-consistency',
+        name: 'Language Consistency',
+        category: 'technical',
+        severity: 'warning',
+        description: 'HTML lang attribute should match the og:locale if present',
+        check: (ctx) => {
+            if (!ctx.hasLang || !ctx.ogLocale)
+                return null;
+            const htmlLang = ctx.langValue?.toLowerCase().split('-')[0];
+            const ogLocaleLang = ctx.ogLocale.toLowerCase().split('_')[0];
+            if (htmlLang !== ogLocaleLang) {
+                return createResult({ id: 'i18n-lang-consistency', name: 'Language Consistency', category: 'technical', severity: 'warning' }, 'warn', `Language mismatch: html lang="${ctx.langValue}" vs og:locale="${ctx.ogLocale}"`, {
+                    recommendation: 'Ensure html lang and og:locale represent the same language',
+                    evidence: {
+                        found: [`html lang="${ctx.langValue}"`, `og:locale="${ctx.ogLocale}"`],
+                        impact: 'Inconsistent language signals can confuse search engines and social platforms',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'i18n-lang-region',
+        name: 'Language Region Specificity',
+        category: 'technical',
+        severity: 'info',
+        description: 'Consider using region-specific language codes for better targeting',
+        check: (ctx) => {
+            if (!ctx.hasLang || !ctx.langValue)
+                return null;
+            const multiRegionalLangs = ['en', 'es', 'pt', 'zh', 'fr', 'de', 'ar'];
+            const langPrimary = ctx.langValue.toLowerCase().split('-')[0];
+            if (multiRegionalLangs.includes(langPrimary) && !ctx.langValue.includes('-')) {
+                return createResult({ id: 'i18n-lang-region', name: 'Language Region Specificity', category: 'technical', severity: 'info' }, 'info', `Consider using region-specific lang code (e.g., ${langPrimary}-US, ${langPrimary}-GB)`, {
+                    recommendation: 'For multi-regional languages, specify the region for better targeting',
+                    evidence: {
+                        found: ctx.langValue,
+                        expected: `${langPrimary}-XX (e.g., en-US, es-ES, pt-BR, zh-CN)`,
+                        impact: 'Helps search engines serve the right regional variant',
+                    },
+                });
+            }
+            return null;
+        },
+    },
+];

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

@@ -2,6 +2,38 @@ import { SeoRule, RuleCategory, RuleSeverity, RuleContext, RuleResult } from './
 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[];

package/dist/seo/rules/index.js

@@ -9,6 +9,16 @@ 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 = [
@@ -23,7 +33,68 @@ export const ALL_SEO_RULES = [
     ...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 = {}) {

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

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