@empline/preflight 1.1.11 → 1.1.13

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

@@ -0,0 +1,650 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * UI Cleanup Preflight
+ *
+ * Validates UI cleanup and migration completeness:
+ * - MUI override detection (leftover .Mui* classes in CSS)
+ * - Scrollbar consistency (utility class usage)
+ * - @supercatch/ui standardization (correct import sources)
+ * - Image optimization (next/image with proper sizing)
+ * - Semantic HTML (proper section/article tags)
+ *
+ * Usage:
+ *   pnpm preflight:ui-cleanup              # All cleanup checks
+ *   pnpm preflight:ui-cleanup mui          # MUI overrides only
+ *   pnpm preflight:ui-cleanup scrollbar    # Scrollbar consistency only
+ *   pnpm preflight:ui-cleanup imports      # Import source validation only
+ *   pnpm preflight:ui-cleanup images       # Image optimization only
+ *   pnpm preflight:ui-cleanup semantic     # Semantic HTML 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.UICleanupPreflightModule = 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 = (0, glob_patterns_1.extendExcludes)(glob_patterns_1.STANDARD_EXCLUDES, ["**/backups/**"]);
+// CACHED FILE LISTS - Scan once, use everywhere
+let _cachedAppComponentsTsxFiles = null;
+async function getAppComponentsTsxFiles() {
+    if (!_cachedAppComponentsTsxFiles) {
+        _cachedAppComponentsTsxFiles = await file_cache_1.fileCache.getAppAndComponentsTSX();
+    }
+    return _cachedAppComponentsTsxFiles;
+}
+let _cachedPageFiles = null;
+async function getPageFiles() {
+    if (!_cachedPageFiles) {
+        _cachedPageFiles = await file_cache_1.fileCache.getPageFiles();
+    }
+    return _cachedPageFiles;
+}
+async function getAppStylesComponentsCss() {
+    return file_cache_1.fileCache.getAppStylesComponentsCss();
+}
+async function getClientFiles() {
+    return file_cache_1.fileCache.getClientFiles();
+}
+// Get concurrency from shared config (respects PREFLIGHT_CONCURRENCY env var)
+const concurrencyConfig = (0, concurrency_config_1.getConcurrencyConfig)();
+class UICleanupPreflightModule {
+    verbose;
+    parallel = false;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+        this.parallel = options.parallel || concurrencyConfig.parallel;
+    }
+    /**
+     * MUI Override Detection - finds leftover .Mui* class overrides in CSS files
+     */
+    async checkMuiOverrides() {
+        const startTime = Date.now();
+        const issues = [];
+        const cssFiles = await getAppStylesComponentsCss();
+        // MUI class patterns to detect
+        const muiPatterns = [
+            /\.Mui[A-Z][a-zA-Z]*-root/g, // .MuiBox-root, .MuiTextField-root
+            /\.Mui[A-Z][a-zA-Z]*-[a-z]+/g, // .MuiButton-contained, .MuiInput-underline
+            /\.MuiSvgIcon-/g, // .MuiSvgIcon-root
+            /\.MuiTypography-/g, // .MuiTypography-body1
+            /\.MuiPaper-/g, // .MuiPaper-root
+            /\.MuiCard-/g, // .MuiCard-root
+            /\.MuiGrid-/g, // .MuiGrid-container
+            /\.MuiContainer-/g, // .MuiContainer-root
+            /\.MuiDialog-/g, // .MuiDialog-paper
+            /\.MuiDrawer-/g, // .MuiDrawer-paper
+            /\.MuiAppBar-/g, // .MuiAppBar-root
+            /\.MuiToolbar-/g, // .MuiToolbar-root
+            /\.MuiTabs-/g, // .MuiTabs-root
+            /\.MuiTab-/g, // .MuiTab-root
+            /\.MuiMenu-/g, // .MuiMenu-paper
+            /\.MuiMenuItem-/g, // .MuiMenuItem-root
+            /\.MuiList-/g, // .MuiList-root
+            /\.MuiListItem-/g, // .MuiListItem-root
+            /\.MuiChip-/g, // .MuiChip-root
+            /\.MuiBadge-/g, // .MuiBadge-root
+            /\.MuiAlert-/g, // .MuiAlert-root
+            /\.MuiSnackbar-/g, // .MuiSnackbar-root
+            /\.MuiTooltip-/g, // .MuiTooltip-tooltip
+            /\.MuiPopover-/g, // .MuiPopover-paper
+            /\.MuiModal-/g, // .MuiModal-root
+            /\.MuiBackdrop-/g, // .MuiBackdrop-root
+            /\.MuiCircularProgress-/g, // .MuiCircularProgress-root
+            /\.MuiLinearProgress-/g, // .MuiLinearProgress-root
+            /\.MuiSkeleton-/g, // .MuiSkeleton-root
+            /\.MuiAvatar-/g, // .MuiAvatar-root
+            /\.MuiDivider-/g, // .MuiDivider-root
+            /\.MuiAccordion-/g, // .MuiAccordion-root
+            /\.MuiFormControl-/g, // .MuiFormControl-root
+            /\.MuiFormLabel-/g, // .MuiFormLabel-root
+            /\.MuiInputBase-/g, // .MuiInputBase-root
+            /\.MuiOutlinedInput-/g, // .MuiOutlinedInput-root
+            /\.MuiFilledInput-/g, // .MuiFilledInput-root
+            /\.MuiSelect-/g, // .MuiSelect-root
+            /\.MuiCheckbox-/g, // .MuiCheckbox-root
+            /\.MuiRadio-/g, // .MuiRadio-root
+            /\.MuiSwitch-/g, // .MuiSwitch-root
+            /\.MuiSlider-/g, // .MuiSlider-root
+            /\.MuiAutocomplete-/g, // .MuiAutocomplete-root
+            /\.MuiRating-/g, // .MuiRating-root
+            /\.MuiPagination-/g, // .MuiPagination-root
+            /\.MuiBreadcrumbs-/g, // .MuiBreadcrumbs-root
+            /\.MuiLink-/g, // .MuiLink-root
+            /\.MuiTable-/g, // .MuiTable-root
+            /\.MuiTableCell-/g, // .MuiTableCell-root
+            /\.MuiTableRow-/g, // .MuiTableRow-root
+            /\.MuiTableHead-/g, // .MuiTableHead-root
+            /\.MuiTableBody-/g, // .MuiTableBody-root
+            /\.MuiTablePagination-/g, // .MuiTablePagination-root
+            /\.MuiStepper-/g, // .MuiStepper-root
+            /\.MuiStep-/g, // .MuiStep-root
+            /\.MuiStepLabel-/g, // .MuiStepLabel-root
+            /\.MuiSpeedDial-/g, // .MuiSpeedDial-root
+            /\.MuiFab-/g, // .MuiFab-root
+            /\.MuiBottomNavigation-/g, // .MuiBottomNavigation-root
+            /\.MuiImageList-/g, // .MuiImageList-root
+            /\.MuiTreeView-/g, // .MuiTreeView-root
+            /\.MuiTimeline-/g, // .MuiTimeline-root
+            /\.MuiDatePicker-/g, // .MuiDatePicker-root
+            /\.MuiTimePicker-/g, // .MuiTimePicker-root
+            /\.MuiDataGrid-/g, // .MuiDataGrid-root
+        ];
+        for (const file of cssFiles) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // Skip comments
+                if (line.trim().startsWith("/*") ||
+                    line.trim().startsWith("*") ||
+                    line.trim().startsWith("//")) {
+                    return;
+                }
+                for (const pattern of muiPatterns) {
+                    pattern.lastIndex = 0;
+                    const match = pattern.exec(line);
+                    if (match) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "mui-override",
+                            severity: "warning",
+                            message: `MUI class override found: ${match[0]}`,
+                            suggestion: "Remove MUI overrides as we've migrated to @supercatch/ui",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            });
+        }
+        return {
+            name: "MUI Override Detection",
+            passed: issues.length === 0,
+            blocking: true, // Warning only - allows gradual cleanup
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Scrollbar Consistency - ensures scrollbar styles use utility classes
+     */
+    async checkScrollbarConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await file_cache_1.fileCache.getFiles("{app,components}/**/*.{tsx,jsx,css}", { ignore: EXCLUDED });
+        // Patterns for ad-hoc scrollbar styling
+        const adHocScrollbarPatterns = [
+            /::-webkit-scrollbar(?!-)/, // Direct scrollbar styling (not in utility class)
+            /scrollbar-width:\s*(?!thin)/, // Non-standard scrollbar-width
+            /scrollbar-color:/, // Direct scrollbar-color (should use utility)
+        ];
+        // Files that are allowed to define scrollbar utilities
+        const allowedFiles = ["globals.css", "tokens.css", "scrollbar.css"];
+        for (const file of files) {
+            const normalizedFile = file.replace(/\\/g, "/");
+            const fileName = normalizedFile.split("/").pop() || "";
+            // Skip files that are allowed to define scrollbar utilities
+            if (allowedFiles.includes(fileName))
+                continue;
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // Skip comments
+                if (line.trim().startsWith("/*") ||
+                    line.trim().startsWith("*") ||
+                    line.trim().startsWith("//")) {
+                    return;
+                }
+                for (const pattern of adHocScrollbarPatterns) {
+                    if (pattern.test(line)) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "adhoc-scrollbar",
+                            severity: "warning",
+                            message: "Ad-hoc scrollbar styling detected",
+                            suggestion: "Use .scroll-container or .scroll-thin utility classes from globals.css",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            });
+        }
+        return {
+            name: "Scrollbar Consistency",
+            passed: issues.length === 0,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Import Source Validation - ensures @supercatch/ui components are imported correctly
+     * Note: components/ui/ files are excluded as they ARE the barrel exports
+     */
+    async checkImportSources() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        // Patterns for incorrect imports
+        const incorrectImportPatterns = [
+            {
+                pattern: /from\s+['"]@supercatch\/ui['"]/,
+                message: "Direct @supercatch/ui import",
+                suggestion: "Import from @/components/ui instead",
+                // Exclude components/ui/ files - they ARE the barrel exports
+                excludePaths: [/components[\\/]ui[\\/]/],
+            },
+            {
+                pattern: /from\s+['"]@mui\/material['"]/,
+                message: "MUI material import",
+                suggestion: "Use @/components/ui components",
+            },
+            {
+                pattern: /from\s+['"]@mui\/icons-material['"]/,
+                message: "MUI icons import",
+                suggestion: "Use lucide-react icons",
+                excludePaths: [],
+            },
+            {
+                pattern: /from\s+['"]@mui\/lab['"]/,
+                message: "MUI lab import",
+                suggestion: "Use @/components/ui components",
+                excludePaths: [],
+            },
+        ];
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            lines.forEach((line, index) => {
+                // Skip comments
+                if (line.trim().startsWith("//") || line.trim().startsWith("/*"))
+                    return;
+                for (const { pattern, message, suggestion, excludePaths } of incorrectImportPatterns) {
+                    // Skip if file matches any exclude path
+                    if (excludePaths && excludePaths.some((ep) => ep.test(file)))
+                        continue;
+                    if (pattern.test(line)) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "incorrect-import",
+                            severity: "error",
+                            message,
+                            suggestion,
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            });
+        }
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "Import Source Validation",
+            passed: !hasErrors,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Image Optimization - checks for next/image usage with proper sizing
+     */
+    async checkImageOptimization() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        // Files that are UI primitives (they handle sizing internally)
+        const uiPrimitiveFiles = ["Avatar.tsx", "CardMedia.tsx", "UnifiedImage.tsx"];
+        for (const file of files) {
+            const normalizedFile = file.replace(/\\/g, "/");
+            const fileName = normalizedFile.split("/").pop() || "";
+            // Skip UI primitive files - they handle sizing internally
+            if (uiPrimitiveFiles.includes(fileName))
+                continue;
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Find img/Image tags by looking for the opening tag and then finding the closing /> or >
+            // This is more reliable than trying to match the entire tag with regex
+            const findJsxTags = (tagName) => {
+                const results = [];
+                const tagPattern = new RegExp(`<${tagName}\\s`, "gi");
+                let match;
+                while ((match = tagPattern.exec(content)) !== null) {
+                    const startIndex = match.index;
+                    const lineNumber = content.substring(0, startIndex).split("\n").length;
+                    // Find the end of this JSX tag (handle nested braces)
+                    let depth = 0;
+                    let inString = false;
+                    let stringChar = "";
+                    let endIndex = startIndex + match[0].length;
+                    for (let i = endIndex; i < content.length; i++) {
+                        const char = content[i];
+                        const prevChar = content[i - 1];
+                        // Handle string literals
+                        if ((char === '"' || char === "'" || char === "`") && prevChar !== "\\") {
+                            if (!inString) {
+                                inString = true;
+                                stringChar = char;
+                            }
+                            else if (char === stringChar) {
+                                inString = false;
+                            }
+                            continue;
+                        }
+                        if (inString)
+                            continue;
+                        // Handle braces
+                        if (char === "{")
+                            depth++;
+                        if (char === "}")
+                            depth--;
+                        // Check for tag end
+                        if (depth === 0) {
+                            if (char === ">" && prevChar === "/") {
+                                endIndex = i + 1;
+                                break;
+                            }
+                            if (char === ">" && prevChar !== "/") {
+                                // Check if this is actually the end (not inside an attribute)
+                                endIndex = i + 1;
+                                break;
+                            }
+                        }
+                    }
+                    const tag = content.substring(startIndex, endIndex);
+                    results.push({ tag, line: lineNumber });
+                }
+                return results;
+            };
+            // Check <img> tags
+            for (const { tag: imgTag, line: lineNumber } of findJsxTags("img")) {
+                // Skip if eslint-disable comment nearby
+                const tagIndex = content.indexOf(imgTag);
+                const contextStart = Math.max(0, tagIndex - 100);
+                const contextBefore = content.substring(contextStart, tagIndex);
+                if (contextBefore.includes("eslint-disable"))
+                    continue;
+                // Check if width and height are present
+                const hasWidth = /\bwidth\s*[=:{]/i.test(imgTag);
+                const hasHeight = /\bheight\s*[=:{]/i.test(imgTag);
+                if (!hasWidth || !hasHeight) {
+                    issues.push({
+                        file,
+                        line: lineNumber,
+                        type: "img-missing-dimensions",
+                        severity: "warning",
+                        message: "Native <img> tag without width/height (causes layout shift)",
+                        suggestion: "Use next/image with width/height props, or add dimensions to prevent CLS",
+                        snippet: imgTag.substring(0, 80).replace(/\s+/g, " "),
+                    });
+                }
+            }
+            // Check <Image> tags (Next.js) - but skip lucide-react icons
+            // Lucide icons use: <Image aria-label="..." /> or have size prop
+            // Next.js Image uses: <Image src="..." />
+            const hasNextImageImport = /import\s+.*\bImage\b.*from\s+['"]next\/image['"]/.test(content);
+            if (hasNextImageImport) {
+                for (const { tag: imageTag, line: lineNumber } of findJsxTags("Image")) {
+                    // Skip if it looks like a lucide icon (has aria-label but no src)
+                    const hasAriaLabel = /aria-label\s*[=:{]/i.test(imageTag);
+                    const hasSrc = /\bsrc\s*[=:{]/i.test(imageTag);
+                    const hasSize = /\bsize\s*[=:{]/i.test(imageTag);
+                    // If it has aria-label but no src, it's likely a lucide icon
+                    if (hasAriaLabel && !hasSrc)
+                        continue;
+                    // If it has size prop (lucide icon pattern), skip
+                    if (hasSize && !hasSrc)
+                        continue;
+                    const hasWidth = /\bwidth\s*[=:{]/i.test(imageTag);
+                    const hasHeight = /\bheight\s*[=:{]/i.test(imageTag);
+                    const hasFill = /\bfill\b/i.test(imageTag);
+                    if (!hasFill && (!hasWidth || !hasHeight)) {
+                        issues.push({
+                            file,
+                            line: lineNumber,
+                            type: "image-missing-dimensions",
+                            severity: "warning",
+                            message: "next/image without width/height or fill prop",
+                            suggestion: "Add width/height props or use fill with a sized container",
+                            snippet: imageTag.substring(0, 80).replace(/\s+/g, " "),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Image Optimization",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Semantic HTML - ensures proper semantic tags are used
+     */
+    async checkSemanticHtml() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await getAppComponentsTsxFiles();
+        // Files that commonly need semantic HTML
+        const pageFiles = await getPageFiles();
+        const clientFiles = await getClientFiles();
+        const sectionFiles = [...pageFiles, ...clientFiles];
+        for (const file of sectionFiles) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            // Track semantic element usage
+            let hasMain = content.includes("<main");
+            let hasSections = content.includes("<section");
+            let hasArticles = content.includes("<article");
+            let hasNav = content.includes("<nav");
+            let hasHeader = content.includes("<header");
+            let hasFooter = content.includes("<footer");
+            // Count div soup indicators
+            let divCount = (content.match(/<div/g) || []).length;
+            let semanticCount = (content.match(/<(main|section|article|nav|header|footer|aside)/g) || [])
+                .length;
+            // If file has many divs but few semantic elements, flag it
+            if (divCount > 10 && semanticCount < 3) {
+                issues.push({
+                    file,
+                    line: 1,
+                    type: "div-soup",
+                    severity: "info",
+                    message: `High div count (${divCount}) with few semantic elements (${semanticCount})`,
+                    suggestion: "Consider using <section>, <article>, <main>, <nav>, <header>, <footer> for better SEO and accessibility",
+                });
+            }
+            // Check for sections without aria-label
+            lines.forEach((line, index) => {
+                if (/<section\s/.test(line) && !line.includes("aria-label")) {
+                    // Check next few lines for aria-label
+                    const contextLines = lines.slice(index, Math.min(index + 3, lines.length)).join("\n");
+                    if (!contextLines.includes("aria-label")) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "section-no-label",
+                            severity: "info",
+                            message: "<section> without aria-label",
+                            suggestion: 'Add aria-label="Section description" for screen readers',
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            });
+        }
+        return {
+            name: "Semantic HTML",
+            passed: true, // Info only, doesn't block
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    async runAll() {
+        const startTime = Date.now();
+        console.log("\n🧹 UI CLEANUP PREFLIGHT");
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        const checks = [];
+        checks.push(await this.checkMuiOverrides());
+        checks.push(await this.checkScrollbarConsistency());
+        checks.push(await this.checkImportSources());
+        checks.push(await this.checkImageOptimization());
+        checks.push(await this.checkSemanticHtml());
+        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-cleanup", 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 CLEANUP RESULTS`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        checks.forEach((check) => {
+            const icon = check.passed
+                ? `${console_chars_1.emoji.success}`
+                : check.blocking
+                    ? `${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}`);
+            if (this.verbose && check.issues.length > 0) {
+                check.issues.slice(0, 5).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} - ${issue.message}`);
+                });
+                if (check.issues.length > 5)
+                    console.log(`   ... and ${check.issues.length - 5} more`);
+            }
+        });
+        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 CLEANUP FAILED (blocking errors found)`);
+        }
+        else if (summary.warnings > 0) {
+            console.log(`\n${console_chars_1.emoji.warning} UI CLEANUP PASSED (with warnings)`);
+        }
+        else {
+            console.log(`\n${console_chars_1.emoji.success} UI CLEANUP PASSED`);
+        }
+    }
+}
+exports.UICleanupPreflightModule = UICleanupPreflightModule;
+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 UICleanupPreflightModule({ verbose, parallel });
+    const runSingle = async (name, fn) => {
+        const check = await fn();
+        const hasBlockingFailure = !check.passed && check.blocking;
+        console.log(`\n${check.passed ? "${emoji.success}" : check.blocking ? "${emoji.error}" : "${emoji.warning}"} ${check.name}: ${check.issues.length} issues`);
+        if (check.issues.length > 0) {
+            check.issues.slice(0, 10).forEach((i) => {
+                const severity = i.severity === "error"
+                    ? `${console_chars_1.emoji.error}`
+                    : i.severity === "warning"
+                        ? `${console_chars_1.emoji.warning}`
+                        : `${console_chars_1.emoji.info}`;
+                console.log(`   ${severity} ${i.file}:${i.line} - ${i.message}`);
+                if (i.suggestion)
+                    console.log(`      ${console_chars_1.chars.arrow} ${i.suggestion}`);
+            });
+            if (check.issues.length > 10)
+                console.log(`   ... and ${check.issues.length - 10} more`);
+        }
+        return {
+            module: `ui-cleanup:${name}`,
+            passed: !hasBlockingFailure,
+            totalDuration: check.duration,
+            checks: [check],
+            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,
+            },
+        };
+    };
+    let result;
+    switch (mode) {
+        case "mui":
+            result = await runSingle("mui", () => module.checkMuiOverrides());
+            break;
+        case "scrollbar":
+            result = await runSingle("scrollbar", () => module.checkScrollbarConsistency());
+            break;
+        case "imports":
+            result = await runSingle("imports", () => module.checkImportSources());
+            break;
+        case "images":
+            result = await runSingle("images", () => module.checkImageOptimization());
+            break;
+        case "semantic":
+            result = await runSingle("semantic", () => module.checkSemanticHtml());
+            break;
+        default:
+            result = await module.runAll();
+            break;
+    }
+    process.exit(result.passed ? 0 : 1);
+}
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=ui-cleanup.js.map