@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/consolidated/ui-state-consistency.js

@@ -0,0 +1,659 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Consolidated UI State Consistency Preflight
+ *
+ * Combines 5 separate state consistency checks into one comprehensive module:
+ * - disabled-state-consistency (disabled states)
+ * - empty-state-consistency (empty states)
+ * - error-state-consistency (error handling)
+ * - hover-state-consistency (hover states)
+ * - loading-state-consistency (loading states)
+ *
+ * Usage:
+ *   pnpm preflight:ui-state              # All state checks
+ *   pnpm preflight:ui-state disabled     # Disabled states only
+ *   pnpm preflight:ui-state empty        # Empty states only
+ *   pnpm preflight:ui-state error        # Error states only
+ *   pnpm preflight:ui-state hover        # Hover states only
+ *   pnpm preflight:ui-state loading      # Loading states 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.UIStateConsistencyModule = void 0;
+const fs = __importStar(require("fs"));
+const file_cache_1 = require("../../shared/file-cache");
+const path = __importStar(require("path"));
+const console_chars_1 = require("../../utils/console-chars");
+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, ["**/ui/**"]);
+// UI components with built-in hover states
+const UI_COMPONENTS_WITH_HOVER = [
+    "Button",
+    "IconButton",
+    "Link",
+    "Chip",
+    "MenuItem",
+    "Tab",
+    "ListItem",
+    "ListItemButton",
+    "Card",
+    "Paper",
+    "Alert",
+    "AccordionSummary",
+    "Fab",
+    "ToggleButton",
+    "StandardButton",
+    "LoadingButton",
+    "AnimatedButton",
+];
+// Allowed empty state patterns
+const ALLOWED_EMPTY_PATTERNS = [
+    "import { EmptyState }",
+    "import { EmptyState,",
+    ", EmptyState }",
+    "import { UnifiedEmptyState }",
+    "import { UnifiedEmptyState,",
+    ", UnifiedEmptyState }",
+    'from "@/components/shared/EmptyState"',
+    'from "@/components/shared"',
+    "<EmptyState",
+    "<UnifiedEmptyState",
+    "CollectionEmptyState",
+    "AdminEmptyState",
+    "emptyMessage=",
+];
+// Patterns that indicate inline empty states (should use shared component)
+const INLINE_EMPTY_STATE_PATTERNS = [
+    // Icon + centered text pattern (common inline empty state)
+    /textAlign:\s*["']center["'][^}]*py:\s*["']var\(--spacing-[68]\)["'][^}]*>[^<]*<\w+\s+size=\{?\d+\}?/,
+    // "No X available/found/yet" patterns
+    /No\s+\w+\s+(Available|Found|Yet|Configured)/i,
+    // "Your X is empty" patterns
+    /Your\s+\w+\s+is\s+empty/i,
+    // "There are no X" patterns
+    /There\s+are\s+no\s+\w+/i,
+    // "Nothing to show/display" patterns
+    /Nothing\s+to\s+(show|display)/i,
+];
+// Get concurrency from shared config (respects PREFLIGHT_CONCURRENCY env var)
+const concurrencyConfig = (0, concurrency_config_1.getConcurrencyConfig)();
+class UIStateConsistencyModule {
+    verbose;
+    parallel = false;
+    strictUniformity;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+        this.parallel = options.parallel ?? concurrencyConfig.parallel;
+        this.strictUniformity =
+            typeof options.strictUniformity === "boolean"
+                ? options.strictUniformity
+                : process.env.PREFLIGHT_STRICT_UNIFORMITY === "1";
+    }
+    async getComponentFiles() {
+        return await file_cache_1.fileCache.getComponentsTsxJsxFiles();
+    }
+    async getAppFiles() {
+        return await file_cache_1.fileCache.getFiles("app/**/*.{tsx,jsx}", {
+            ignore: ["**/node_modules/**", "**/.next/**", "**/loading.tsx"],
+        });
+    }
+    /**
+     * Disabled State Consistency
+     */
+    async checkDisabled() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getComponentFiles();
+        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;
+                // Button without disabled prop (submit or onClick)
+                if (/<Button[^>]*>/i.test(line) && !line.includes("disabled")) {
+                    if (line.includes('type="submit"') || line.includes("onClick")) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "button-no-disabled",
+                            severity: "info",
+                            message: "Button without disabled prop",
+                            suggestion: "Add disabled={isLoading} or disabled={!isValid}",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Custom interactive without aria-disabled
+                if (/<div[^>]*onClick/i.test(line) &&
+                    !line.includes("aria-disabled") &&
+                    !line.includes("disabled")) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "custom-interactive-no-disabled",
+                        severity: "warning",
+                        message: "Custom interactive element without disabled support",
+                        suggestion: "Add aria-disabled attribute",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            });
+        }
+        return {
+            name: "Disabled State Consistency",
+            passed: true,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Empty State Consistency
+     *
+     * Detects inline empty states that should use the shared EmptyState or UnifiedEmptyState component.
+     * Common patterns:
+     * - Icon + centered text with "No X available"
+     * - "Your X is empty" messages
+     * - "There are no X" messages
+     */
+    async checkEmpty() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getAppFiles();
+        const skipPaths = [
+            "help/",
+            "admin/integrations/",
+            "loading.tsx",
+            "EmptyState.tsx",
+            "UnifiedEmptyState.tsx",
+        ];
+        for (const file of files) {
+            if (skipPaths.some((skip) => file.includes(skip)))
+                continue;
+            const content = fs.readFileSync(file, "utf8");
+            const usesSharedEmptyState = ALLOWED_EMPTY_PATTERNS.some((p) => content.includes(p));
+            // Strip most quoted string literals to avoid false positives from copy text in data arrays
+            // (e.g., FAQs or marketing copy containing phrases like "There are no ...").
+            const contentWithoutStringLiterals = content
+                .replace(/`[\s\S]*?`/g, "")
+                .replace(/"(?:\\.|[^"\\])*"/g, "")
+                .replace(/'(?:\\.|[^'\\])*'/g, "");
+            // Skip if already using shared empty state
+            if (usesSharedEmptyState)
+                continue;
+            // Centering consistency for inline empty states
+            // Steering rule: centered content blocks should use flex + items-center to avoid subtle mis-centering.
+            // We only flag when the file strongly looks like it contains an inline empty-state.
+            const likelyEmptyCopy = /(No\s+\w+|Your\s+\w+\s+is\s+empty|There\s+are\s+no\s+\w+|Nothing\s+to\s+(show|display)|not\s+found)/i.test(content);
+            const hasCenteredClassBlock = /className=\{?\s*["'][^"']*\btext-center\b[^"']*["']\s*\}?/m.test(content);
+            const hasStandardCenteredFlex = /className=\{?\s*["'][^"']*\bflex\b[^"']*\bflex-col\b[^"']*\bitems-center\b[^"']*\btext-center\b[^"']*["']\s*\}?/m.test(content);
+            const hasGapOrSpaceY = /className=\{?\s*["'][^"']*(?:\bgap-\d+\b|\bspace-y-\d+\b)[^"']*["']\s*\}?/m.test(content);
+            const hasLikelyIcon = /from\s+["']lucide-react["']/.test(content) ||
+                /<\w+\s+[^>]*(?:size=\{?\d+\}?|className=\{?\s*["'][^"']*(?:h-\d+|w-\d+)[^"']*["']\s*\}?)/.test(content);
+            if (likelyEmptyCopy && hasCenteredClassBlock && hasLikelyIcon && !hasStandardCenteredFlex) {
+                const match = content.match(/className=\{?\s*["'][^"']*\btext-center\b[^"']*["']\s*\}?/m);
+                const matchIndex = match?.index ?? 0;
+                const lineNumber = content.substring(0, matchIndex).split("\n").length;
+                issues.push({
+                    file,
+                    line: lineNumber,
+                    type: "empty-state-centering-pattern",
+                    severity: "warning",
+                    message: "Centered empty-state content should use flex flex-col items-center (not text-center alone)",
+                    suggestion: 'Use className="flex flex-col items-center text-center" on the empty-state container (or use <UnifiedEmptyState />)',
+                    snippet: match?.[0]?.substring(0, 120),
+                });
+            }
+            // If a file already uses the standard centered flex empty-state container, require explicit vertical spacing.
+            // This is a heuristic that prevents icon/title/description from collapsing together.
+            if (likelyEmptyCopy && hasStandardCenteredFlex && hasLikelyIcon && !hasGapOrSpaceY) {
+                const match = content.match(/className=\{?\s*["'][^"']*\bflex\b[^"']*\bflex-col\b[^"']*\bitems-center\b[^"']*\btext-center\b[^"']*["']\s*\}?/m);
+                const matchIndex = match?.index ?? 0;
+                // Only warn when empty-state copy appears near the centered container to reduce false positives.
+                const ctxStart = Math.max(0, matchIndex - 600);
+                const ctxEnd = Math.min(content.length, matchIndex + 600);
+                const localContext = content.substring(ctxStart, ctxEnd);
+                const localLikelyEmptyCopy = /(No\s+\w+|Your\s+\w+\s+is\s+empty|There\s+are\s+no\s+\w+|Nothing\s+to\s+(show|display)|not\s+found)/i.test(localContext);
+                if (localLikelyEmptyCopy) {
+                    const lineNumber = content.substring(0, matchIndex).split("\n").length;
+                    issues.push({
+                        file,
+                        line: lineNumber,
+                        type: "empty-state-missing-gap",
+                        severity: "warning",
+                        message: "Centered empty-state container should include gap-* or space-y-* for vertical spacing",
+                        suggestion: "Add gap-4 (or space-y-4) to the flex flex-col items-center text-center container (or use <UnifiedEmptyState />)",
+                        snippet: match?.[0]?.substring(0, 120),
+                    });
+                }
+            }
+            // Check for inline empty state patterns
+            for (const pattern of INLINE_EMPTY_STATE_PATTERNS) {
+                const match = pattern.source.includes("textAlign:")
+                    ? content.match(pattern)
+                    : contentWithoutStringLiterals.match(pattern);
+                if (match) {
+                    const matchIndex = content.indexOf(match[0]);
+                    const lineNumber = content.substring(0, matchIndex).split("\n").length;
+                    issues.push({
+                        file,
+                        line: lineNumber,
+                        type: "inline-empty-state",
+                        severity: this.strictUniformity ? "error" : "warning",
+                        message: "Inline empty state detected - use shared EmptyState or UnifiedEmptyState component",
+                        suggestion: 'Import { UnifiedEmptyState } from "@/components/shared" and use variant="no-items" or similar',
+                        snippet: match[0].substring(0, 100),
+                    });
+                    break; // Only report once per file
+                }
+            }
+            // Check for centered Box with icon pattern (common inline empty state)
+            const centeredIconPattern = /sx=\{\{[^}]*textAlign:\s*["']center["'][^}]*\}\}[^]*?size=\{?\d+\}?[^]*?(No\s+\w+|empty|not found)/i;
+            const centeredMatch = content.match(centeredIconPattern);
+            if (centeredMatch && !usesSharedEmptyState) {
+                const matchIndex = content.indexOf(centeredMatch[0]);
+                const lineNumber = content.substring(0, matchIndex).split("\n").length;
+                // Check if this issue was already reported
+                const alreadyReported = issues.some((i) => i.file === file && i.type === "inline-empty-state");
+                if (!alreadyReported) {
+                    issues.push({
+                        file,
+                        line: lineNumber,
+                        type: "inline-empty-state",
+                        severity: this.strictUniformity ? "error" : "warning",
+                        message: "Centered icon + text empty state - use shared UnifiedEmptyState component",
+                        suggestion: 'Import { UnifiedEmptyState } from "@/components/shared" with appropriate variant',
+                        snippet: centeredMatch[0].substring(0, 100),
+                    });
+                }
+            }
+            // Shared empty state component should enforce basic spacing so inline consumers don't regress.
+            // This is a lightweight static guard (not a pixel-perfect check).
+            try {
+                const sharedPath = "components/shared/UnifiedEmptyState.tsx";
+                if (fs.existsSync(sharedPath)) {
+                    const shared = fs.readFileSync(sharedPath, "utf8");
+                    const hasVerticalGapStack = /flex\s+flex-col\s+items-center\s+gap-\d+/.test(shared);
+                    const hasTestIds = shared.includes('data-testid="unified-empty-state"') &&
+                        shared.includes('data-testid="unified-empty-state-icon"');
+                    if (!hasVerticalGapStack || !hasTestIds) {
+                        issues.push({
+                            file: sharedPath,
+                            type: "shared-empty-state-spacing",
+                            severity: "warning",
+                            message: "UnifiedEmptyState should enforce icon/title/description spacing (gap-based) and expose stable test ids",
+                            suggestion: "Use a flex flex-col items-center gap-* stack for icon+text and add data-testid attributes",
+                        });
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+            // Check for .map() without any obvious empty-state handling.
+            // This heuristic is intentionally low-severity because many server components
+            // guarantee non-empty arrays via upstream queries.
+            const hasMap = content.includes(".map(");
+            const hasAnyLengthCheck = /\b\.length\b/.test(content) ||
+                /length\s*(?:===|!==|>|<)\s*0/.test(content) ||
+                /!\w+\?\.length/.test(content);
+            if (this.verbose && hasMap && !hasAnyLengthCheck) {
+                issues.push({
+                    file,
+                    type: "map-no-empty-state",
+                    severity: "info",
+                    message: "File uses .map() but has no obvious empty state handling",
+                    suggestion: "If user-facing, consider adding an empty state (prefer <UnifiedEmptyState />)",
+                });
+            }
+        }
+        const hasErrors = issues.some((i) => i.severity === "error");
+        return {
+            name: "Empty State Consistency",
+            passed: !hasErrors,
+            blocking: this.strictUniformity && hasErrors,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Error State Consistency
+     */
+    async checkError() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getComponentFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            const hasForm = content.includes("<form") || content.includes("onSubmit");
+            const hasErrorState = /error|Error/.test(content);
+            lines.forEach((line, index) => {
+                if (line.trim().startsWith("//"))
+                    return;
+                // TextField without error prop
+                if (/<TextField[^>]*>/i.test(line) &&
+                    !line.includes("error") &&
+                    !line.includes("helperText")) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "textfield-no-error",
+                        severity: "info",
+                        message: "TextField without error handling",
+                        suggestion: "Add error={!!errors.field} and helperText",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Async without try-catch
+                if (/const\s+\w+\s*=\s*async/.test(line) &&
+                    !content.includes("try") &&
+                    !content.includes("catch")) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "async-no-error-handling",
+                        severity: "warning",
+                        message: "Async function without error handling",
+                        suggestion: "Add try-catch block",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            });
+            if (hasForm && !hasErrorState) {
+                issues.push({
+                    file,
+                    type: "form-no-error-state",
+                    severity: "warning",
+                    message: "Form without error state management",
+                    suggestion: "Add error state and validation",
+                });
+            }
+        }
+        return {
+            name: "Error State Consistency",
+            passed: true,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Hover State Consistency
+     */
+    async checkHover() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getComponentFiles();
+        const uiPattern = new RegExp(`<(${UI_COMPONENTS_WITH_HOVER.join("|")})\\b`, "i");
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            const hasCursorInFile = content.includes("cursor:") || content.includes("cursor-pointer");
+            lines.forEach((line, index) => {
+                if (line.trim().startsWith("//") || /^\s*import\s+/.test(line))
+                    return;
+                if (!/<\w+/.test(line))
+                    return;
+                // onClick on plain elements without cursor
+                if (/<(div|span|section)\s/i.test(line) &&
+                    line.includes("onClick") &&
+                    !line.includes("cursor") &&
+                    !hasCursorInFile) {
+                    const surroundingLines = lines
+                        .slice(Math.max(0, index - 5), Math.min(lines.length, index + 15))
+                        .join("\n");
+                    if (!surroundingLines.includes("cursor:") &&
+                        !surroundingLines.includes("cursor-pointer")) {
+                        issues.push({
+                            file,
+                            line: index + 1,
+                            type: "onclick-no-cursor",
+                            severity: "warning",
+                            message: "onClick without cursor: pointer",
+                            suggestion: 'Add style={{ cursor: "pointer" }}',
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            });
+        }
+        return {
+            name: "Hover State Consistency",
+            passed: true,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Loading State Consistency
+     */
+    async checkLoading() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getComponentFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            const hasAsyncFunction = /const\s+\w+\s*=\s*async\s*\(|async\s+function/.test(content);
+            const hasLoadingState = /useState.*loading/i.test(content) || /isLoading/i.test(content);
+            const hasLoadingIndicator = content.includes("CircularProgress") ||
+                content.includes("Spinner") ||
+                content.includes("SkeletonLoader");
+            lines.forEach((line, index) => {
+                if (line.trim().startsWith("//"))
+                    return;
+                // Fetch without loading state
+                if (/(fetch|axios)\s*\(/i.test(line) &&
+                    !content.includes("isLoading") &&
+                    !content.includes("loading")) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "fetch-no-loading",
+                        severity: "warning",
+                        message: "Fetch/axios without loading state",
+                        suggestion: "Add loading state",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Async onClick without loading
+                if (/onClick=\{async\s*\(/.test(line)) {
+                    issues.push({
+                        file,
+                        line: index + 1,
+                        type: "async-onclick-no-loading",
+                        severity: "warning",
+                        message: "Async onClick without loading feedback",
+                        suggestion: "Add loading state and indicator",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            });
+            if (hasAsyncFunction && !hasLoadingState && !hasLoadingIndicator) {
+                issues.push({
+                    file,
+                    type: "async-no-loading-state",
+                    severity: "warning",
+                    message: "File has async operations but no loading state",
+                    suggestion: "Add loading state management",
+                });
+            }
+        }
+        return {
+            name: "Loading State Consistency",
+            passed: true,
+            blocking: true,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    async runAll() {
+        const startTime = Date.now();
+        console.log(`\n${console_chars_1.emoji.refresh} CONSOLIDATED UI STATE CONSISTENCY PREFLIGHT`);
+        console.log((0, console_chars_1.createDivider)(80, "heavy"));
+        const checks = [];
+        checks.push(await this.checkDisabled());
+        checks.push(await this.checkEmpty());
+        checks.push(await this.checkError());
+        checks.push(await this.checkHover());
+        checks.push(await this.checkLoading());
+        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-state-consistency",
+            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 STATE CONSISTENCY 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}`);
+        });
+        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 STATE CONSISTENCY FAILED (blocking errors found)`);
+        }
+        else {
+            console.log(`\n${console_chars_1.emoji.success} UI STATE CONSISTENCY PASSED`);
+        }
+    }
+}
+exports.UIStateConsistencyModule = UIStateConsistencyModule;
+async function main() {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)(path.basename(__filename, ".ts"));
+    const args = process.argv.slice(2);
+    const flags = new Set(args.filter((a) => a.startsWith("-")));
+    const positional = args.filter((a) => !a.startsWith("-"));
+    const mode = positional[0] || "all";
+    const verbose = flags.has("--verbose") || flags.has("-v");
+    const strictUniformity = flags.has("--strict") ||
+        flags.has("--strict-uniformity") ||
+        process.env.PREFLIGHT_STRICT_UNIFORMITY === "1";
+    const module = new UIStateConsistencyModule({ verbose, strictUniformity });
+    const runSingle = async (name, fn) => {
+        const check = await fn();
+        const hasBlockingFailure = !check.passed && check.blocking;
+        console.log(`\n${check.passed ? "${emoji.success}" : "${emoji.error}"} ${check.name}: ${check.issues.length} issues`);
+        if (check.issues.length > 0) {
+            const severityRank = {
+                error: 0,
+                warning: 1,
+                info: 2,
+            };
+            const issuesSorted = [...check.issues].sort((a, b) => {
+                const ar = severityRank[a.severity] ?? 9;
+                const br = severityRank[b.severity] ?? 9;
+                if (ar !== br)
+                    return ar - br;
+                if (a.file !== b.file)
+                    return a.file.localeCompare(b.file);
+                return (a.line ?? 0) - (b.line ?? 0);
+            });
+            const toPrint = verbose ? issuesSorted : issuesSorted.slice(0, 5);
+            toPrint.forEach((i) => {
+                const lineSuffix = typeof i.line === "number" ? `:${i.line}` : "";
+                console.log(`   [${i.severity}] ${i.file}${lineSuffix} - ${i.message}`);
+            });
+            if (!verbose && issuesSorted.length > 5)
+                console.log(`   ... and ${issuesSorted.length - 5} more`);
+        }
+        return {
+            module: `ui-state:${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 "disabled":
+            result = await runSingle("disabled", () => module.checkDisabled());
+            break;
+        case "empty":
+            result = await runSingle("empty", () => module.checkEmpty());
+            break;
+        case "error":
+            result = await runSingle("error", () => module.checkError());
+            break;
+        case "hover":
+            result = await runSingle("hover", () => module.checkHover());
+            break;
+        case "loading":
+            result = await runSingle("loading", () => module.checkLoading());
+            break;
+        default:
+            result = await module.runAll();
+            break;
+    }
+    process.exit(result.passed ? 0 : 1);
+}
+if (require.main === module) {
+    main();
+}
+//# sourceMappingURL=ui-state-consistency.js.map