npm - recker - Versions diffs - 1.0.27 → 1.0.28-next.3bf98c7 - Mend

recker 1.0.27 → 1.0.28-next.3bf98c7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (72) hide show

package/dist/browser/scrape/extractors.js +2 -1
package/dist/browser/scrape/types.d.ts +2 -1
package/dist/cli/index.js +142 -3
package/dist/cli/tui/shell.d.ts +2 -0
package/dist/cli/tui/shell.js +492 -1
package/dist/index.d.ts +1 -0
package/dist/index.js +1 -0
package/dist/scrape/extractors.js +2 -1
package/dist/scrape/index.d.ts +2 -0
package/dist/scrape/index.js +1 -0
package/dist/scrape/spider.d.ts +61 -0
package/dist/scrape/spider.js +250 -0
package/dist/scrape/types.d.ts +2 -1
package/dist/seo/analyzer.d.ts +42 -0
package/dist/seo/analyzer.js +742 -0
package/dist/seo/index.d.ts +7 -0
package/dist/seo/index.js +3 -0
package/dist/seo/rules/accessibility.d.ts +2 -0
package/dist/seo/rules/accessibility.js +694 -0
package/dist/seo/rules/best-practices.d.ts +2 -0
package/dist/seo/rules/best-practices.js +188 -0
package/dist/seo/rules/content.d.ts +2 -0
package/dist/seo/rules/content.js +236 -0
package/dist/seo/rules/crawl.d.ts +2 -0
package/dist/seo/rules/crawl.js +307 -0
package/dist/seo/rules/cwv.d.ts +2 -0
package/dist/seo/rules/cwv.js +337 -0
package/dist/seo/rules/ecommerce.d.ts +2 -0
package/dist/seo/rules/ecommerce.js +252 -0
package/dist/seo/rules/i18n.d.ts +2 -0
package/dist/seo/rules/i18n.js +222 -0
package/dist/seo/rules/images.d.ts +2 -0
package/dist/seo/rules/images.js +180 -0
package/dist/seo/rules/index.d.ts +52 -0
package/dist/seo/rules/index.js +143 -0
package/dist/seo/rules/internal-linking.d.ts +2 -0
package/dist/seo/rules/internal-linking.js +375 -0
package/dist/seo/rules/links.d.ts +2 -0
package/dist/seo/rules/links.js +150 -0
package/dist/seo/rules/local.d.ts +2 -0
package/dist/seo/rules/local.js +265 -0
package/dist/seo/rules/meta.d.ts +2 -0
package/dist/seo/rules/meta.js +523 -0
package/dist/seo/rules/mobile.d.ts +2 -0
package/dist/seo/rules/mobile.js +71 -0
package/dist/seo/rules/performance.d.ts +2 -0
package/dist/seo/rules/performance.js +246 -0
package/dist/seo/rules/pwa.d.ts +2 -0
package/dist/seo/rules/pwa.js +302 -0
package/dist/seo/rules/readability.d.ts +2 -0
package/dist/seo/rules/readability.js +255 -0
package/dist/seo/rules/schema.d.ts +2 -0
package/dist/seo/rules/schema.js +54 -0
package/dist/seo/rules/security.d.ts +2 -0
package/dist/seo/rules/security.js +525 -0
package/dist/seo/rules/social.d.ts +2 -0
package/dist/seo/rules/social.js +373 -0
package/dist/seo/rules/structural.d.ts +2 -0
package/dist/seo/rules/structural.js +155 -0
package/dist/seo/rules/technical.d.ts +2 -0
package/dist/seo/rules/technical.js +223 -0
package/dist/seo/rules/thresholds.d.ts +196 -0
package/dist/seo/rules/thresholds.js +118 -0
package/dist/seo/rules/types.d.ts +346 -0
package/dist/seo/rules/types.js +11 -0
package/dist/seo/seo-spider.d.ts +47 -0
package/dist/seo/seo-spider.js +362 -0
package/dist/seo/types.d.ts +184 -0
package/dist/seo/types.js +1 -0
package/dist/utils/columns.d.ts +14 -0
package/dist/utils/columns.js +69 -0
package/package.json +1 -1

package/dist/seo/rules/performance.js ADDED Viewed

@@ -0,0 +1,246 @@
+import { createResult } from './types.js';
+import { SEO_THRESHOLDS } from './thresholds.js';
+export const performanceRules = [
+    {
+        id: 'perf-preconnect',
+        name: 'Preconnect Hints',
+        category: 'performance',
+        severity: 'info',
+        description: 'Use preconnect for important third-party origins',
+        check: (ctx) => {
+            if (!ctx.hasPreconnect && ctx.externalLinks && ctx.externalLinks > 5) {
+                return createResult({ id: 'perf-preconnect', name: 'Preconnect Hints', category: 'performance', severity: 'info' }, 'info', 'No preconnect hints found', { recommendation: 'Add <link rel="preconnect" href="..."> for important third-party domains' });
+            }
+            if (ctx.preconnectCount && ctx.preconnectCount > 0) {
+                return createResult({ id: 'perf-preconnect', name: 'Preconnect Hints', category: 'performance', severity: 'info' }, 'pass', `${ctx.preconnectCount} preconnect hint(s) found`, { value: ctx.preconnectCount });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'perf-dns-prefetch',
+        name: 'DNS Prefetch',
+        category: 'performance',
+        severity: 'info',
+        description: 'Use dns-prefetch for external domains',
+        check: (ctx) => {
+            if (ctx.dnsPrefetchCount && ctx.dnsPrefetchCount > 0) {
+                return createResult({ id: 'perf-dns-prefetch', name: 'DNS Prefetch', category: 'performance', severity: 'info' }, 'pass', `${ctx.dnsPrefetchCount} dns-prefetch hint(s) found`, { value: ctx.dnsPrefetchCount });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'perf-preload',
+        name: 'Preload Hints',
+        category: 'performance',
+        severity: 'info',
+        description: 'Use preload for critical resources',
+        check: (ctx) => {
+            if (ctx.preloadCount && ctx.preloadCount > 0) {
+                return createResult({ id: 'perf-preload', name: 'Preload Hints', category: 'performance', severity: 'info' }, 'pass', `${ctx.preloadCount} preload hint(s) found`, { value: ctx.preloadCount });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'perf-render-blocking',
+        name: 'Render Blocking',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Minimize render-blocking resources',
+        check: (ctx) => {
+            const blocking = ctx.renderBlockingResources ?? 0;
+            if (blocking > 5) {
+                return createResult({ id: 'perf-render-blocking', name: 'Render Blocking', category: 'performance', severity: 'warning' }, 'warn', `${blocking} render-blocking resources in <head>`, { value: blocking, recommendation: 'Use async/defer for scripts, preload for critical CSS' });
+            }
+            if (blocking > 0) {
+                return createResult({ id: 'perf-render-blocking', name: 'Render Blocking', category: 'performance', severity: 'warning' }, 'info', `${blocking} render-blocking resource(s) in <head>`, { value: blocking });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'perf-inline-styles',
+        name: 'Inline Styles',
+        category: 'performance',
+        severity: 'info',
+        description: 'Excessive inline styles can increase page size',
+        check: (ctx) => {
+            const inline = ctx.inlineStylesCount ?? 0;
+            if (inline > 10) {
+                return createResult({ id: 'perf-inline-styles', name: 'Inline Styles', category: 'performance', severity: 'info' }, 'info', `${inline} inline style blocks found`, { value: inline, recommendation: 'Consider consolidating inline styles into external CSS' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'cwv-lcp-lazy',
+        name: 'LCP Image Lazy',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Above-the-fold images should not use lazy loading',
+        check: (ctx) => {
+            if (ctx.lcpHints?.hasLazyLcp) {
+                return createResult({ id: 'cwv-lcp-lazy', name: 'LCP Image Lazy', category: 'performance', severity: 'warning' }, 'warn', 'First large image uses lazy loading (may hurt LCP)', { recommendation: 'Remove loading="lazy" from above-the-fold images' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'cwv-lcp-priority',
+        name: 'LCP Priority Hints',
+        category: 'performance',
+        severity: 'info',
+        description: 'Use fetchpriority="high" for LCP images',
+        check: (ctx) => {
+            if (ctx.lcpHints?.hasLargeImages && !ctx.lcpHints?.hasPriorityHints) {
+                return createResult({ id: 'cwv-lcp-priority', name: 'LCP Priority Hints', category: 'performance', severity: 'info' }, 'info', 'No fetchpriority="high" found on large images', { recommendation: 'Add fetchpriority="high" to LCP candidate images' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'cwv-cls-images',
+        name: 'CLS Image Dimensions',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Images without dimensions cause layout shifts',
+        check: (ctx) => {
+            const missing = ctx.clsHints?.imagesWithoutDimensions ?? ctx.imagesMissingDimensions ?? 0;
+            if (missing > 0) {
+                return createResult({ id: 'cwv-cls-images', name: 'CLS Image Dimensions', category: 'performance', severity: 'warning' }, 'warn', `${missing} image(s) without width/height (causes CLS)`, { value: missing, recommendation: 'Add width and height attributes to all images' });
+            }
+            return null;
+        },
+    },
+    {
+        id: 'timing-ttfb',
+        name: 'Time to First Byte',
+        category: 'performance',
+        severity: 'error',
+        description: 'TTFB should be under 600ms (ideally under 200ms)',
+        check: (ctx) => {
+            const ttfb = ctx.timings?.ttfb;
+            if (ttfb === undefined)
+                return null;
+            const { good, needsImprovement, poor } = SEO_THRESHOLDS.timing.ttfb;
+            if (ttfb <= good) {
+                return createResult({ id: 'timing-ttfb', name: 'TTFB', category: 'performance', severity: 'error' }, 'pass', `Excellent TTFB (${ttfb}ms)`, { value: ttfb });
+            }
+            if (ttfb <= needsImprovement) {
+                return createResult({ id: 'timing-ttfb', name: 'TTFB', category: 'performance', severity: 'error' }, 'info', `TTFB needs improvement (${ttfb}ms)`, { value: ttfb, recommendation: `Optimize server response time to under ${good}ms` });
+            }
+            if (ttfb <= poor) {
+                return createResult({ id: 'timing-ttfb', name: 'TTFB', category: 'performance', severity: 'error' }, 'warn', `Slow TTFB (${ttfb}ms)`, { value: ttfb, recommendation: 'Optimize server, use CDN, enable caching' });
+            }
+            return createResult({ id: 'timing-ttfb', name: 'TTFB', category: 'performance', severity: 'error' }, 'fail', `Very slow TTFB (${ttfb}ms)`, { value: ttfb, recommendation: 'Critical: Server is too slow. Check server, database, and network' });
+        },
+    },
+    {
+        id: 'timing-total',
+        name: 'Total Load Time',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Total page load should be under 2.5s',
+        check: (ctx) => {
+            const total = ctx.timings?.total;
+            if (total === undefined)
+                return null;
+            const { good, needsImprovement, poor } = SEO_THRESHOLDS.timing.total;
+            if (total <= good) {
+                return createResult({ id: 'timing-total', name: 'Load Time', category: 'performance', severity: 'warning' }, 'pass', `Fast page load (${total}ms)`, { value: total });
+            }
+            if (total <= needsImprovement) {
+                return createResult({ id: 'timing-total', name: 'Load Time', category: 'performance', severity: 'warning' }, 'info', `Page load time acceptable (${total}ms)`, { value: total, recommendation: `Aim for under ${good}ms for better user experience` });
+            }
+            if (total <= poor) {
+                return createResult({ id: 'timing-total', name: 'Load Time', category: 'performance', severity: 'warning' }, 'warn', `Slow page load (${total}ms)`, { value: total, recommendation: 'Optimize assets, enable compression, use CDN' });
+            }
+            return createResult({ id: 'timing-total', name: 'Load Time', category: 'performance', severity: 'warning' }, 'fail', `Very slow page load (${total}ms)`, { value: total, recommendation: 'Critical performance issue. Full optimization needed.' });
+        },
+    },
+    {
+        id: 'timing-dns',
+        name: 'DNS Lookup',
+        category: 'performance',
+        severity: 'info',
+        description: 'DNS lookup should be under 50ms',
+        check: (ctx) => {
+            const dns = ctx.timings?.dnsLookup;
+            if (dns === undefined)
+                return null;
+            const { good, poor } = SEO_THRESHOLDS.timing.dnsLookup;
+            if (dns <= good) {
+                return createResult({ id: 'timing-dns', name: 'DNS Lookup', category: 'performance', severity: 'info' }, 'pass', `Fast DNS lookup (${dns}ms)`, { value: dns });
+            }
+            if (dns <= poor) {
+                return createResult({ id: 'timing-dns', name: 'DNS Lookup', category: 'performance', severity: 'info' }, 'info', `DNS lookup could be faster (${dns}ms)`, { value: dns, recommendation: 'Consider using faster DNS provider or dns-prefetch' });
+            }
+            return createResult({ id: 'timing-dns', name: 'DNS Lookup', category: 'performance', severity: 'info' }, 'warn', `Slow DNS lookup (${dns}ms)`, { value: dns, recommendation: 'DNS is slow. Consider Cloudflare, Google DNS, or dns-prefetch' });
+        },
+    },
+    {
+        id: 'timing-tls',
+        name: 'TLS Handshake',
+        category: 'performance',
+        severity: 'info',
+        description: 'TLS handshake should be under 100ms',
+        check: (ctx) => {
+            const tls = ctx.timings?.tlsHandshake;
+            if (tls === undefined)
+                return null;
+            const { good, poor } = SEO_THRESHOLDS.timing.tlsHandshake;
+            if (tls <= good) {
+                return createResult({ id: 'timing-tls', name: 'TLS Handshake', category: 'performance', severity: 'info' }, 'pass', `Fast TLS handshake (${tls}ms)`, { value: tls });
+            }
+            if (tls <= poor) {
+                return createResult({ id: 'timing-tls', name: 'TLS Handshake', category: 'performance', severity: 'info' }, 'info', `TLS handshake could be faster (${tls}ms)`, { value: tls, recommendation: 'Consider TLS 1.3, HTTP/2, or preconnect hints' });
+            }
+            return createResult({ id: 'timing-tls', name: 'TLS Handshake', category: 'performance', severity: 'info' }, 'warn', `Slow TLS handshake (${tls}ms)`, { value: tls, recommendation: 'TLS is slow. Check server configuration and certificate chain' });
+        },
+    },
+    {
+        id: 'response-html-size',
+        name: 'HTML Size',
+        category: 'performance',
+        severity: 'warning',
+        description: 'HTML should be under 500KB (ideally under 100KB)',
+        check: (ctx) => {
+            const size = ctx.htmlSize;
+            if (size === undefined)
+                return null;
+            const { good, warning, poor } = SEO_THRESHOLDS.responseSize.html;
+            const sizeKb = Math.round(size / 1024);
+            if (size <= good) {
+                return createResult({ id: 'response-html-size', name: 'HTML Size', category: 'performance', severity: 'warning' }, 'pass', `HTML size is good (${sizeKb}KB)`, { value: sizeKb });
+            }
+            if (size <= warning) {
+                return createResult({ id: 'response-html-size', name: 'HTML Size', category: 'performance', severity: 'warning' }, 'info', `HTML size is acceptable (${sizeKb}KB)`, { value: sizeKb, recommendation: 'Consider reducing HTML size for faster parsing' });
+            }
+            if (size <= poor) {
+                return createResult({ id: 'response-html-size', name: 'HTML Size', category: 'performance', severity: 'warning' }, 'warn', `HTML is large (${sizeKb}KB)`, { value: sizeKb, recommendation: 'Reduce HTML size. Check for inline data, remove unused code' });
+            }
+            return createResult({ id: 'response-html-size', name: 'HTML Size', category: 'performance', severity: 'warning' }, 'fail', `HTML is very large (${sizeKb}KB)`, { value: sizeKb, recommendation: 'Critical: HTML too large. Use pagination, lazy loading, or split content' });
+        },
+    },
+    {
+        id: 'response-compression',
+        name: 'Compression',
+        category: 'performance',
+        severity: 'warning',
+        description: 'Response should be compressed (gzip/brotli)',
+        check: (ctx) => {
+            if (ctx.htmlSize === undefined)
+                return null;
+            if (ctx.isCompressed === false && ctx.htmlSize > 1024) {
+                return createResult({ id: 'response-compression', name: 'Compression', category: 'performance', severity: 'warning' }, 'warn', 'Response is not compressed', { recommendation: 'Enable gzip or brotli compression on server' });
+            }
+            if (ctx.isCompressed === true) {
+                const ratio = ctx.compressedSize && ctx.htmlSize ? Math.round((ctx.compressedSize / ctx.htmlSize) * 100) : undefined;
+                return createResult({ id: 'response-compression', name: 'Compression', category: 'performance', severity: 'warning' }, 'pass', ratio ? `Response compressed (${ratio}% of original)` : 'Response is compressed');
+            }
+            return null;
+        },
+    },
+];

package/dist/seo/rules/pwa.d.ts ADDED Viewed

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

package/dist/seo/rules/pwa.js ADDED Viewed

@@ -0,0 +1,302 @@
+import { createResult } from './types.js';
+export const pwaRules = [
+    {
+        id: 'pwa-manifest-link',
+        name: 'Web App Manifest',
+        category: 'technical',
+        severity: 'info',
+        description: 'Pages should link to a web app manifest for PWA support',
+        check: (ctx) => {
+            if (ctx.hasManifest === undefined)
+                return null;
+            if (!ctx.hasManifest) {
+                return createResult({ id: 'pwa-manifest-link', name: 'Web App Manifest', category: 'technical', severity: 'info' }, 'info', 'No web app manifest linked', {
+                    recommendation: 'Add a manifest.json for PWA installability',
+                    evidence: {
+                        expected: '<link rel="manifest" href="/manifest.json">',
+                        impact: 'Required for "Add to Home Screen" and PWA features',
+                        learnMore: 'https://web.dev/add-manifest/',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-manifest-link', name: 'Web App Manifest', category: 'technical', severity: 'info' }, 'pass', `Manifest linked${ctx.manifestUrl ? `: ${ctx.manifestUrl}` : ''}`);
+        },
+    },
+    {
+        id: 'pwa-theme-color',
+        name: 'Theme Color',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Pages should define a theme color for browser UI',
+        check: (ctx) => {
+            if (ctx.themeColor === undefined)
+                return null;
+            if (!ctx.themeColor) {
+                return createResult({ id: 'pwa-theme-color', name: 'Theme Color', category: 'mobile', severity: 'info' }, 'info', 'No theme-color meta tag', {
+                    recommendation: 'Add theme-color for browser UI customization',
+                    evidence: {
+                        expected: '<meta name="theme-color" content="#4285f4">',
+                        impact: 'Controls browser toolbar color on mobile devices',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-theme-color', name: 'Theme Color', category: 'mobile', severity: 'info' }, 'pass', `Theme color: ${ctx.themeColor}`);
+        },
+    },
+    {
+        id: 'pwa-apple-touch-icon',
+        name: 'Apple Touch Icon',
+        category: 'mobile',
+        severity: 'info',
+        description: 'iOS devices need apple-touch-icon for home screen',
+        check: (ctx) => {
+            if (ctx.hasAppleTouchIcon === undefined)
+                return null;
+            if (!ctx.hasAppleTouchIcon) {
+                return createResult({ id: 'pwa-apple-touch-icon', name: 'Apple Touch Icon', category: 'mobile', severity: 'info' }, 'info', 'No apple-touch-icon found', {
+                    recommendation: 'Add apple-touch-icon for iOS home screen',
+                    evidence: {
+                        expected: '<link rel="apple-touch-icon" href="/apple-touch-icon.png">',
+                        impact: 'iOS uses this icon when user adds site to home screen',
+                        example: 'Recommended size: 180x180 pixels',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-apple-touch-icon', name: 'Apple Touch Icon', category: 'mobile', severity: 'info' }, 'pass', 'Apple touch icon present');
+        },
+    },
+    {
+        id: 'pwa-apple-mobile-capable',
+        name: 'Apple Mobile Web App',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Enable standalone mode on iOS devices',
+        check: (ctx) => {
+            if (ctx.hasAppleMobileWebAppCapable === undefined)
+                return null;
+            if (!ctx.hasAppleMobileWebAppCapable) {
+                return createResult({ id: 'pwa-apple-mobile-capable', name: 'Apple Mobile Web App', category: 'mobile', severity: 'info' }, 'info', 'No apple-mobile-web-app-capable meta tag', {
+                    recommendation: 'Add for full-screen iOS experience',
+                    evidence: {
+                        expected: '<meta name="apple-mobile-web-app-capable" content="yes">',
+                        impact: 'Enables standalone app mode when launched from home screen',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-apple-mobile-capable', name: 'Apple Mobile Web App', category: 'mobile', severity: 'info' }, 'pass', 'Apple mobile web app capable enabled');
+        },
+    },
+    {
+        id: 'pwa-apple-status-bar',
+        name: 'Apple Status Bar Style',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Configure iOS status bar appearance',
+        check: (ctx) => {
+            if (!ctx.hasAppleMobileWebAppCapable)
+                return null;
+            if (ctx.appleStatusBarStyle === undefined)
+                return null;
+            if (!ctx.appleStatusBarStyle) {
+                return createResult({ id: 'pwa-apple-status-bar', name: 'Apple Status Bar Style', category: 'mobile', severity: 'info' }, 'info', 'No apple-mobile-web-app-status-bar-style defined', {
+                    recommendation: 'Define status bar style for iOS',
+                    evidence: {
+                        expected: '<meta name="apple-mobile-web-app-status-bar-style" content="black-translucent">',
+                        example: 'Options: default, black, black-translucent',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-apple-status-bar', name: 'Apple Status Bar Style', category: 'mobile', severity: 'info' }, 'pass', `Status bar style: ${ctx.appleStatusBarStyle}`);
+        },
+    },
+    {
+        id: 'pwa-maskable-icon',
+        name: 'Maskable Icon',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Manifest should include maskable icons for Android',
+        check: (ctx) => {
+            if (ctx.hasMaskableIcon === undefined)
+                return null;
+            if (!ctx.hasMaskableIcon) {
+                return createResult({ id: 'pwa-maskable-icon', name: 'Maskable Icon', category: 'mobile', severity: 'info' }, 'info', 'No maskable icon in manifest', {
+                    recommendation: 'Add maskable icon for adaptive icons on Android',
+                    evidence: {
+                        example: `{
+  "icons": [{
+    "src": "/icon-maskable.png",
+    "sizes": "512x512",
+    "type": "image/png",
+    "purpose": "maskable"
+  }]
+}`,
+                        impact: 'Maskable icons adapt to different Android icon shapes',
+                        learnMore: 'https://web.dev/maskable-icon/',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-maskable-icon', name: 'Maskable Icon', category: 'mobile', severity: 'info' }, 'pass', 'Maskable icon defined');
+        },
+    },
+    {
+        id: 'pwa-start-url',
+        name: 'Start URL',
+        category: 'technical',
+        severity: 'info',
+        description: 'Manifest should define a start_url',
+        check: (ctx) => {
+            if (!ctx.hasManifest)
+                return null;
+            if (ctx.manifestStartUrl === undefined)
+                return null;
+            if (!ctx.manifestStartUrl) {
+                return createResult({ id: 'pwa-start-url', name: 'Start URL', category: 'technical', severity: 'info' }, 'info', 'Manifest missing start_url', {
+                    recommendation: 'Define start_url in manifest for PWA launch',
+                    evidence: {
+                        expected: '"start_url": "/?source=pwa"',
+                        impact: 'Controls which page opens when PWA is launched',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-start-url', name: 'Start URL', category: 'technical', severity: 'info' }, 'pass', `Start URL: ${ctx.manifestStartUrl}`);
+        },
+    },
+    {
+        id: 'pwa-display-mode',
+        name: 'Display Mode',
+        category: 'technical',
+        severity: 'info',
+        description: 'Manifest should define display mode',
+        check: (ctx) => {
+            if (!ctx.hasManifest)
+                return null;
+            if (ctx.manifestDisplay === undefined)
+                return null;
+            const display = ctx.manifestDisplay;
+            if (!display) {
+                return createResult({ id: 'pwa-display-mode', name: 'Display Mode', category: 'technical', severity: 'info' }, 'info', 'Manifest missing display mode', {
+                    recommendation: 'Set display mode for app-like experience',
+                    evidence: {
+                        expected: '"display": "standalone"',
+                        example: 'Options: fullscreen, standalone, minimal-ui, browser',
+                    },
+                });
+            }
+            const goodModes = ['standalone', 'fullscreen', 'minimal-ui'];
+            if (!goodModes.includes(display)) {
+                return createResult({ id: 'pwa-display-mode', name: 'Display Mode', category: 'technical', severity: 'info' }, 'info', `Display mode: ${display} (browser-like)`, {
+                    recommendation: 'Consider standalone or fullscreen for app-like experience',
+                });
+            }
+            return createResult({ id: 'pwa-display-mode', name: 'Display Mode', category: 'technical', severity: 'info' }, 'pass', `Display mode: ${display}`);
+        },
+    },
+    {
+        id: 'pwa-scope',
+        name: 'Navigation Scope',
+        category: 'technical',
+        severity: 'info',
+        description: 'Manifest should define navigation scope',
+        check: (ctx) => {
+            if (!ctx.hasManifest)
+                return null;
+            if (ctx.manifestScope === undefined)
+                return null;
+            if (!ctx.manifestScope) {
+                return createResult({ id: 'pwa-scope', name: 'Navigation Scope', category: 'technical', severity: 'info' }, 'info', 'Manifest missing scope', {
+                    recommendation: 'Define scope to control PWA navigation boundaries',
+                    evidence: {
+                        expected: '"scope": "/"',
+                        impact: 'Limits which URLs are part of the app experience',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-scope', name: 'Navigation Scope', category: 'technical', severity: 'info' }, 'pass', `Scope: ${ctx.manifestScope}`);
+        },
+    },
+    {
+        id: 'pwa-icons-sizes',
+        name: 'Icon Sizes',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Manifest should include multiple icon sizes',
+        check: (ctx) => {
+            if (!ctx.hasManifest)
+                return null;
+            if (ctx.manifestIconSizes === undefined)
+                return null;
+            const sizes = ctx.manifestIconSizes;
+            const requiredSizes = [192, 512];
+            const missingSizes = requiredSizes.filter(s => !sizes.includes(s));
+            if (missingSizes.length > 0) {
+                return createResult({ id: 'pwa-icons-sizes', name: 'Icon Sizes', category: 'mobile', severity: 'info' }, 'info', `Missing icon sizes: ${missingSizes.join(', ')}px`, {
+                    recommendation: 'Add icons in required sizes',
+                    evidence: {
+                        found: sizes.length > 0 ? sizes.map(s => `${s}px`).join(', ') : 'No icons',
+                        expected: '192x192 and 512x512 minimum',
+                        impact: 'Required for Chrome "Add to Home Screen" prompt',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-icons-sizes', name: 'Icon Sizes', category: 'mobile', severity: 'info' }, 'pass', `Icon sizes: ${sizes.map(s => `${s}px`).join(', ')}`);
+        },
+    },
+    {
+        id: 'pwa-short-name',
+        name: 'Short Name',
+        category: 'technical',
+        severity: 'info',
+        description: 'Manifest should have a short_name for home screen',
+        check: (ctx) => {
+            if (!ctx.hasManifest)
+                return null;
+            if (ctx.manifestShortName === undefined && ctx.manifestName === undefined)
+                return null;
+            const shortName = ctx.manifestShortName;
+            const name = ctx.manifestName;
+            if (!shortName && !name) {
+                return createResult({ id: 'pwa-short-name', name: 'Short Name', category: 'technical', severity: 'info' }, 'info', 'Manifest missing name and short_name', {
+                    recommendation: 'Add short_name (max 12 chars) for home screen label',
+                    evidence: {
+                        expected: '"short_name": "MyApp"',
+                        impact: 'Used as app label on home screen',
+                    },
+                });
+            }
+            if (shortName && shortName.length > 12) {
+                return createResult({ id: 'pwa-short-name', name: 'Short Name', category: 'technical', severity: 'info' }, 'info', `Short name too long: ${shortName.length} chars`, {
+                    recommendation: 'Keep short_name under 12 characters',
+                    evidence: {
+                        found: shortName,
+                        expected: 'Max 12 characters',
+                        impact: 'May be truncated on home screen',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-short-name', name: 'Short Name', category: 'technical', severity: 'info' }, 'pass', `App name: ${shortName || name}`);
+        },
+    },
+    {
+        id: 'pwa-background-color',
+        name: 'Background Color',
+        category: 'mobile',
+        severity: 'info',
+        description: 'Manifest should define background_color for splash screen',
+        check: (ctx) => {
+            if (!ctx.hasManifest)
+                return null;
+            if (ctx.manifestBackgroundColor === undefined)
+                return null;
+            if (!ctx.manifestBackgroundColor) {
+                return createResult({ id: 'pwa-background-color', name: 'Background Color', category: 'mobile', severity: 'info' }, 'info', 'Manifest missing background_color', {
+                    recommendation: 'Define background_color for splash screen',
+                    evidence: {
+                        expected: '"background_color": "#ffffff"',
+                        impact: 'Shown as splash screen background during app launch',
+                    },
+                });
+            }
+            return createResult({ id: 'pwa-background-color', name: 'Background Color', category: 'mobile', severity: 'info' }, 'pass', `Background color: ${ctx.manifestBackgroundColor}`);
+        },
+    },
+];

package/dist/seo/rules/readability.d.ts ADDED Viewed

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