@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/consolidated/ui-navigation.js

@@ -0,0 +1,673 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Consolidated UI Navigation Preflight
+ *
+ * Combines 4 separate navigation checks into one comprehensive module:
+ * - breadcrumb-validation (breadcrumb mappings)
+ * - link-text-quality (descriptive link text)
+ * - footer-placement-validation (footer positioning)
+ * - shared-layout-patterns (AdminPageLayout, AccountPageLayout usage)
+ *
+ * Usage:
+ *   pnpm preflight:ui-navigation              # All navigation checks
+ *   pnpm preflight:ui-navigation breadcrumbs  # Breadcrumb mappings only
+ *   pnpm preflight:ui-navigation links        # Link text quality only
+ *   pnpm preflight:ui-navigation usage        # Internal/External link usage
+ *   pnpm preflight:ui-navigation footer       # Footer placement only
+ *   pnpm preflight:ui-navigation layouts      # Shared layout patterns only
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UINavigationModule = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+const file_cache_1 = require("../../shared/file-cache");
+const glob_patterns_1 = require("../../shared/glob-patterns");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+const concurrency_config_1 = require("../../shared/concurrency-config");
+const EXCLUDED = [...glob_patterns_1.STANDARD_EXCLUDES];
+// Routes that are explicitly excluded from breadcrumb validation
+// (they have special handling or are intentionally Home-only)
+const BREADCRUMB_EXCLUDED_ROUTES = [
+    "/", // Homepage
+    "/login", // Auth pages
+    "/register",
+    "/api", // API routes
+    "/auth", // Auth routes
+    "/checkout", // Checkout flow
+    "/cart", // Cart page
+];
+// Routes that are handled by dynamic patterns (category pages, etc.)
+const DYNAMIC_BREADCRUMB_PATTERNS = [
+    /^\/admin\//, // Admin pages have special handling
+    /^\/store\//, // Store/seller pages have special handling
+    /^\/seller\//, // Legacy seller pages
+    /^\/account\//, // Account pages have special handling
+    /^\/blog\//, // Blog pages have special handling
+    /^\/sports-cards\//, // Category pages
+    /^\/trading-card-games\//,
+    /^\/video-games\//,
+    /^\/autographs\//,
+    /^\/non-sports-cards\//,
+    /^\/tickets\//,
+    /^\/checklists\//,
+    /^\/features\//, // Features subpages
+    /^\/sell\//, // Sell subpages
+    /^\/search/, // Search pages
+    /^\/product\//, // Product pages
+    /^\/listing\//, // Listing pages
+];
+const GENERIC_LINK_TEXT = [
+    "click here",
+    "here",
+    "read more",
+    "more",
+    "link",
+    "this",
+    "learn more",
+    "view",
+    "see more",
+    "details",
+    "info",
+];
+// CACHED FILE LISTS - Scan once, use everywhere
+let _cachedPageFiles = null;
+async function getPageFiles() {
+    if (!_cachedPageFiles) {
+        _cachedPageFiles = await file_cache_1.fileCache.getPageFiles();
+    }
+    return _cachedPageFiles;
+}
+// CACHED FILE LISTS - Scan once, use everywhere
+let _cachedAppComponentsTsxFiles = null;
+async function getAppComponentsTsxFiles() {
+    if (!_cachedAppComponentsTsxFiles) {
+        _cachedAppComponentsTsxFiles = await file_cache_1.fileCache.getAppAndComponentsTSX();
+    }
+    return _cachedAppComponentsTsxFiles;
+}
+// Get concurrency from shared config (respects PREFLIGHT_CONCURRENCY env var)
+const concurrencyConfig = (0, concurrency_config_1.getConcurrencyConfig)();
+class UINavigationModule {
+    verbose;
+    parallel = false;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+        this.parallel = options.parallel || concurrencyConfig.parallel;
+    }
+    /**
+     * Breadcrumb Validation - ensures ALL pages have proper breadcrumb mappings
+     *
+     * This check scans all page files and verifies they have breadcrumb mappings
+     * that will show more than just "Home". Pages without proper mappings will
+     * only show "Home" in breadcrumbs, which is poor UX.
+     */
+    async checkBreadcrumbs() {
+        const startTime = Date.now();
+        const issues = [];
+        const pages = await getPageFiles();
+        const mappingFile = path.join(process.cwd(), "lib/navigation/url-mapping.ts");
+        if (!fs.existsSync(mappingFile)) {
+            issues.push({
+                file: mappingFile,
+                type: "missing-mapping-file",
+                severity: "error",
+                message: "url-mapping.ts file not found",
+                suggestion: "Create lib/navigation/url-mapping.ts",
+            });
+            return {
+                name: "Breadcrumb Validation",
+                passed: false,
+                blocking: true,
+                issues,
+                duration: Date.now() - startTime,
+            };
+        }
+        const mappingContent = fs.readFileSync(mappingFile, "utf8");
+        // Extract all static page mappings from the file
+        const staticMappingsMatch = mappingContent.match(/staticPageMappings[^{]*{([^}]+)}/s);
+        const staticMappings = new Set();
+        if (staticMappingsMatch) {
+            const mappingsBlock = staticMappingsMatch[1];
+            const pathMatches = mappingsBlock.matchAll(/["']([^"']+)["']\s*:/g);
+            for (const match of pathMatches) {
+                staticMappings.add(match[1]);
+            }
+        }
+        // Extract category landing pages
+        const categoryLandingMatch = mappingContent.match(/categoryLandingPages[^{]*{([^}]+)}/s);
+        if (categoryLandingMatch) {
+            const landingBlock = categoryLandingMatch[1];
+            const pathMatches = landingBlock.matchAll(/["']([^"']+)["']\s*:/g);
+            for (const match of pathMatches) {
+                staticMappings.add(match[1]);
+            }
+        }
+        for (const page of pages) {
+            // Normalize path separators first (Windows uses backslashes)
+            const normalizedPage = page.replace(/\\/g, "/");
+            let urlPath = normalizedPage.replace(/^app/, "").replace(/\/page\.tsx$/, "");
+            if (urlPath === "")
+                urlPath = "/";
+            // Skip explicitly excluded routes
+            if (BREADCRUMB_EXCLUDED_ROUTES.some((ex) => urlPath === ex || urlPath.startsWith(ex + "/")))
+                continue;
+            // Skip dynamic routes (contain [param])
+            if (urlPath.includes("["))
+                continue;
+            // Skip routes handled by dynamic patterns
+            if (DYNAMIC_BREADCRUMB_PATTERNS.some((pattern) => pattern.test(urlPath)))
+                continue;
+            // Skip route groups (parentheses in path like /(store)/)
+            if (urlPath.includes("(") && urlPath.includes(")")) {
+                // Extract the actual path without route groups
+                urlPath = urlPath.replace(/\/\([^)]+\)/g, "");
+                if (urlPath === "" || urlPath === "/")
+                    continue;
+            }
+            // Check if this path has a mapping
+            const hasStaticMapping = staticMappings.has(urlPath);
+            // Check if it's a category landing page (e.g., /sports-cards, /autographs)
+            const isCategoryLanding = [
+                "/sports-cards",
+                "/autographs",
+                "/non-sports-cards",
+                "/trading-card-games",
+                "/video-games",
+                "/tickets",
+                "/checklists",
+                "/more",
+            ].includes(urlPath);
+            // Check if it's handled by navigation structure
+            const isInNavigationStructure = mappingContent.includes(`path: "${urlPath}"`) ||
+                mappingContent.includes(`path: '${urlPath}'`);
+            if (!hasStaticMapping && !isCategoryLanding && !isInNavigationStructure) {
+                issues.push({
+                    file: page,
+                    type: "missing-breadcrumb",
+                    severity: "error",
+                    message: `Page "${urlPath}" has no breadcrumb mapping - will only show "Home"`,
+                    suggestion: `Add "${urlPath}": "Page Title" to staticPageMappings in lib/navigation/url-mapping.ts`,
+                });
+            }
+        }
+        // Sort issues by path for easier reading
+        issues.sort((a, b) => a.message.localeCompare(b.message));
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "Breadcrumb Validation",
+            passed: !hasErrors,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Link Text Quality - ensures links have descriptive text
+     */
+    async checkLinkText() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                if (line.trim().startsWith("//"))
+                    return;
+                // Check for links with generic text
+                const linkMatch = line.match(/<(?:a|Link)[^>]*>([^<]+)<\/(?:a|Link)>/i);
+                if (linkMatch) {
+                    const linkText = linkMatch[1].toLowerCase().trim();
+                    if (GENERIC_LINK_TEXT.includes(linkText)) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "generic-link-text",
+                            severity: "warning",
+                            message: `Generic link text: "${linkText}"`,
+                            suggestion: "Use descriptive text",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for empty links
+                if (/<(?:a|Link)[^>]*>\s*<\/(?:a|Link)>/i.test(line)) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "empty-link",
+                        severity: "error",
+                        message: "Empty link without text",
+                        suggestion: "Add link text or aria-label",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Check for icon-only links without aria-label
+                if (/<(?:a|Link)[^>]*>.*<.*Icon.*>.*<\/(?:a|Link)>/i.test(line) &&
+                    !line.includes("aria-label")) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "icon-link-no-label",
+                        severity: "error",
+                        message: "Icon-only link without aria-label",
+                        suggestion: "Add aria-label for accessibility",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            });
+        }
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "Link Text Quality",
+            passed: !hasErrors,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Link Usage - ensures proper usage of internal/external links
+     * - Internal links should use Next.js <Link>
+     * - External links with target="_blank" must have rel="noopener noreferrer"
+     */
+    async checkLinkUsage() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                if (line.trim().startsWith("//"))
+                    return;
+                if (line.includes("preflight-ignore"))
+                    return;
+                // Check for <a> tags used for internal links
+                const anchorMatch = line.match(/<a[^>]*href=["'](\/[^"']*)["'][^>]*>/);
+                if (anchorMatch && !line.includes("download")) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "internal-anchor",
+                        severity: "warning",
+                        message: `Internal link "${anchorMatch[1]}" uses <a> tag instead of Next.js <Link>`,
+                        suggestion: 'Use <Link href="..."> for client-side navigation',
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Check for target="_blank" security
+                if (line.includes('target="_blank"') || line.includes("target='_blank'")) {
+                    // Check same line
+                    if (line.includes('rel="noopener noreferrer"') ||
+                        line.includes("rel='noopener noreferrer'")) {
+                        return;
+                    }
+                    // Check context (5 lines around)
+                    const context = lines
+                        .slice(Math.max(0, index - 5), Math.min(lines.length, index + 5))
+                        .join(" ");
+                    if (context.includes('rel="noopener noreferrer"') ||
+                        context.includes("rel='noopener noreferrer'")) {
+                        return;
+                    }
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "unsafe-target-blank",
+                        severity: "error",
+                        message: 'External link with target="_blank" missing rel="noopener noreferrer"',
+                        suggestion: 'Add rel="noopener noreferrer" to prevent security vulnerability',
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            });
+        }
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "Link Usage Security",
+            passed: !hasErrors,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Footer Placement - ensures Footer is outside flex containers and not hidden
+     */
+    async checkFooterPlacement() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        // Files where showFooter={false} is allowed (component definitions with defaults)
+        const ALLOWED_SHOW_FOOTER_FALSE = [
+            "components/layout/PageShellLayout.tsx", // MinimalPageShell preset
+            "components/shared/SellerPageLayout.tsx", // Layout component definition
+            "components/shared/AdminPageLayout.tsx",
+            "components/shared/AccountPageLayout.tsx",
+        ];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const normalizedPath = file.replace(/\\/g, "/");
+            // Skip allowed files (component definitions)
+            const isAllowed = ALLOWED_SHOW_FOOTER_FALSE.some((allowed) => normalizedPath.endsWith(allowed));
+            // Check for showFooter={false} in JSX usage (not in default params)
+            // Pattern: showFooter={false} in JSX context (not as default parameter)
+            if (!isAllowed && /showFooter\s*=\s*\{\s*false\s*\}/.test(content)) {
+                const lines = content.split("\n");
+                for (let i = 0; i < lines.length; i++) {
+                    const line = lines[i];
+                    // Skip if it's a default parameter (= false at end of param)
+                    if (/showFooter\s*=\s*false\s*[,)]/.test(line))
+                        continue;
+                    // Skip if it's a JSDoc example
+                    if (line.trim().startsWith("*") || line.trim().startsWith("//"))
+                        continue;
+                    if (/showFooter\s*=\s*\{\s*false\s*\}/.test(line)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "footer-hidden",
+                            severity: "error",
+                            message: "Footer is explicitly hidden with showFooter={false}",
+                            suggestion: "Remove showFooter={false} - footer should always be visible for consistent UX",
+                            snippet: line.trim().substring(0, 100),
+                        });
+                    }
+                }
+            }
+            if (!content.includes("<Footer") || !content.includes("Sidebar"))
+                continue;
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                if (/<Footer\s*\/?>/.test(lines[i])) {
+                    const nextLines = lines.slice(i, i + 5).join("\n");
+                    // Check for incorrect pattern: Footer -> </Box> -> </Box>
+                    if (/<Footer\s*\/>[\s\n]*<\/Box>[\s\n]*<\/Box>/.test(nextLines)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "footer-inside-flex",
+                            severity: "error",
+                            message: "Footer inside flex container (should be outside)",
+                            suggestion: "Move Footer outside flex container, before </ServerLayout>",
+                            snippet: lines[i].trim(),
+                        });
+                    }
+                }
+            }
+        }
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "Footer Placement",
+            passed: !hasErrors,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Shared Layout Patterns - ensures pages use AdminPageLayout, AccountPageLayout, etc.
+     */
+    async checkSharedLayouts() {
+        const startTime = Date.now();
+        const issues = [];
+        const ADMIN_OLD_PATTERNS = [
+            /import\s+{[^}]*AdminSidebar[^}]*}\s+from\s+["']@\/components\/AdminSidebar["']/,
+            /import\s+{[^}]*DynamicAdminSidebar\s+as\s+AdminSidebar[^}]*}\s+from\s+["']@\/lib\/dynamic-imports["']/,
+        ];
+        const ACCOUNT_OLD_PATTERNS = [
+            /import\s+{[^}]*DashboardSidebar[^}]*}\s+from\s+["']@\/components\/DashboardSidebar["']/,
+            /import\s+{[^}]*DynamicDashboardSidebar\s+as\s+DashboardSidebar[^}]*}\s+from\s+["']@\/lib\/dynamic-imports["']/,
+        ];
+        const EXCEPTIONS = ["app/admin/templates/TemplatesClient.tsx"];
+        // Check admin files
+        const adminFiles = await file_cache_1.fileCache.getFiles("app/admin/**/*Client.tsx", { ignore: EXCLUDED });
+        for (const file of adminFiles) {
+            if (file.includes("layout.tsx") || file.includes("Layout.tsx"))
+                continue;
+            if (EXCEPTIONS.some((exc) => file.replace(/\\/g, "/").endsWith(exc)))
+                continue;
+            const content = fs.readFileSync(file, "utf8");
+            if (!content.includes('"use client"') && !content.includes("'use client'"))
+                continue;
+            // Skip if using AdminPageLayout
+            if (content.includes("AdminPageLayout"))
+                continue;
+            for (const pattern of ADMIN_OLD_PATTERNS) {
+                if (pattern.test(content)) {
+                    issues.push({
+                        file,
+                        type: "admin-bypass-layout",
+                        severity: "error",
+                        message: "Uses AdminSidebar directly instead of AdminPageLayout",
+                        suggestion: "Replace ServerLayout + AdminSidebar + Footer with <AdminPageLayout>content</AdminPageLayout>",
+                    });
+                    break;
+                }
+            }
+        }
+        // Check account files
+        const accountFiles = await file_cache_1.fileCache.getFiles("app/account/**/*Client.tsx", { ignore: EXCLUDED });
+        for (const file of accountFiles) {
+            if (file.includes("layout.tsx") || file.includes("Layout.tsx"))
+                continue;
+            if (EXCEPTIONS.some((exc) => file.replace(/\\/g, "/").endsWith(exc)))
+                continue;
+            const content = fs.readFileSync(file, "utf8");
+            if (!content.includes('"use client"') && !content.includes("'use client'"))
+                continue;
+            // Skip if using AccountPageLayout
+            if (content.includes("AccountPageLayout"))
+                continue;
+            for (const pattern of ACCOUNT_OLD_PATTERNS) {
+                if (pattern.test(content)) {
+                    issues.push({
+                        file,
+                        type: "account-bypass-layout",
+                        severity: "error",
+                        message: "Uses DashboardSidebar directly instead of AccountPageLayout",
+                        suggestion: "Replace ServerLayout + DashboardSidebar + Footer with <AccountPageLayout>content</AccountPageLayout>",
+                    });
+                    break;
+                }
+            }
+        }
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "Shared Layout Patterns",
+            passed: !hasErrors,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    async runAll() {
+        const startTime = Date.now();
+        console.log("\n🧭 CONSOLIDATED UI NAVIGATION PREFLIGHT");
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        const checks = [];
+        checks.push(await this.checkBreadcrumbs());
+        checks.push(await this.checkLinkText());
+        checks.push(await this.checkLinkUsage());
+        checks.push(await this.checkFooterPlacement());
+        checks.push(await this.checkSharedLayouts());
+        const totalDuration = Date.now() - startTime;
+        const allIssues = checks.flatMap((c) => c.issues);
+        const hasBlockingFailure = checks.some((c) => !c.passed && c.blocking);
+        const summary = {
+            total: checks.length,
+            passed: checks.filter((c) => c.passed).length,
+            failed: checks.filter((c) => !c.passed).length,
+            errors: allIssues.filter((i) => i.severity === "error").length,
+            warnings: allIssues.filter((i) => i.severity === "warning").length,
+        };
+        this.printResults(checks, totalDuration, summary, hasBlockingFailure);
+        return { module: "ui-navigation", passed: !hasBlockingFailure, totalDuration, checks, summary };
+    }
+    printResults(checks, totalDuration, summary, hasBlockingFailure) {
+        console.log("\n" + (0, console_chars_1.createDivider)(80, "heavy"));
+        console.log(`${console_chars_1.emoji.chart} UI NAVIGATION RESULTS`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        checks.forEach((check) => {
+            const icon = check.issues.length === 0
+                ? `${console_chars_1.emoji.success}`
+                : check.blocking && !check.passed
+                    ? `${console_chars_1.emoji.error}`
+                    : `${console_chars_1.emoji.warning}`;
+            const count = check.issues.length > 0 ? ` (${check.issues.length} issues)` : "";
+            console.log(`${icon} ${check.name.padEnd(30)} ${(check.duration / 1000).toFixed(1)}s${count}`);
+            // Print issues for failed checks
+            if (check.issues.length > 0 && this.verbose) {
+                check.issues.forEach((issue) => {
+                    const severity = issue.severity === "error"
+                        ? `${console_chars_1.emoji.error}`
+                        : issue.severity === "warning"
+                            ? `${console_chars_1.emoji.warning}`
+                            : `${console_chars_1.emoji.info}`;
+                    console.log(`   ${severity} ${issue.message}`);
+                    if (issue.suggestion) {
+                        console.log(`      ${console_chars_1.chars.arrow} ${issue.suggestion}`);
+                    }
+                });
+            }
+            else if (check.issues.length > 0 && check.issues.length <= 10) {
+                // Show first 10 issues even without verbose
+                check.issues.slice(0, 10).forEach((issue) => {
+                    const severity = issue.severity === "error"
+                        ? `${console_chars_1.emoji.error}`
+                        : issue.severity === "warning"
+                            ? `${console_chars_1.emoji.warning}`
+                            : `${console_chars_1.emoji.info}`;
+                    console.log(`   ${severity} ${issue.file}:${issue.line || 0}`);
+                    console.log(`      ${issue.message}`);
+                });
+                if (check.issues.length > 10) {
+                    console.log(`   ... and ${check.issues.length - 10} more issues`);
+                }
+            }
+        });
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        console.log(`Errors: ${summary.errors} | Warnings: ${summary.warnings} | Time: ${(totalDuration / 1000).toFixed(1)}s`);
+        if (hasBlockingFailure) {
+            console.log(`\n${console_chars_1.emoji.error} UI NAVIGATION FAILED (blocking errors found)`);
+        }
+        else {
+            console.log(`\n${console_chars_1.emoji.success} UI NAVIGATION PASSED`);
+        }
+    }
+}
+exports.UINavigationModule = UINavigationModule;
+async function main() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(path.basename(__filename, ".ts"));
+    const args = process.argv.slice(2);
+    const mode = args[0] || "all";
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    const parallel = args.includes("--parallel") || args.includes("-p");
+    const module = new UINavigationModule({ verbose, parallel });
+    const runSingle = async (name, fn) => {
+        console.log(`\n🧭 UI NAVIGATION: ${name.toUpperCase()}`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        const check = await fn();
+        const hasBlockingFailure = !check.passed && check.blocking;
+        const summary = {
+            total: 1,
+            passed: check.passed ? 1 : 0,
+            failed: check.passed ? 0 : 1,
+            errors: check.issues.filter((i) => i.severity === "error").length,
+            warnings: check.issues.filter((i) => i.severity === "warning").length,
+        };
+        // Print issues
+        const icon = check.issues.length === 0
+            ? `${console_chars_1.emoji.success}`
+            : check.blocking && !check.passed
+                ? `${console_chars_1.emoji.error}`
+                : `${console_chars_1.emoji.warning}`;
+        console.log(`${icon} ${check.name}: ${check.issues.length} issues`);
+        if (check.issues.length > 0) {
+            check.issues.forEach((issue) => {
+                const severity = issue.severity === "error"
+                    ? `${console_chars_1.emoji.error}`
+                    : issue.severity === "warning"
+                        ? `${console_chars_1.emoji.warning}`
+                        : `${console_chars_1.emoji.info}`;
+                console.log(`   ${severity} ${issue.file}:${issue.line || 0}`);
+                console.log(`      ${issue.message}`);
+                if (issue.suggestion) {
+                    console.log(`      ${console_chars_1.chars.arrow} ${issue.suggestion}`);
+                }
+            });
+        }
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        console.log(`Errors: ${summary.errors} | Warnings: ${summary.warnings}`);
+        console.log(hasBlockingFailure ? `\n${console_chars_1.emoji.error} FAILED` : `\n${console_chars_1.emoji.success} PASSED`);
+        return {
+            module: `ui-navigation:${name}`,
+            passed: !hasBlockingFailure,
+            totalDuration: check.duration,
+            checks: [check],
+            summary,
+        };
+    };
+    let result;
+    switch (mode) {
+        case "breadcrumbs":
+            result = await runSingle("breadcrumbs", () => module.checkBreadcrumbs());
+            break;
+        case "links":
+            result = await runSingle("links", () => module.checkLinkText());
+            break;
+        case "usage":
+            result = await runSingle("usage", () => module.checkLinkUsage());
+            break;
+        case "footer":
+            result = await runSingle("footer", () => module.checkFooterPlacement());
+            break;
+        case "layouts":
+            result = await runSingle("layouts", () => module.checkSharedLayouts());
+            break;
+        default:
+            result = await module.runAll();
+            break;
+    }
+    process.exit(result.passed ? 0 : 1);
+}
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=ui-navigation.js.map