@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/consolidated/ui-visual-hierarchy.d.ts

@@ -0,0 +1,90 @@
+#!/usr/bin/env tsx
+/**
+ * UI Visual Hierarchy Preflight (NON-BLOCKING)
+ *
+ * Validates visual hierarchy and content prioritization.
+ *
+ * Checks:
+ * 1. Heading Level Progression - h1→h2→h3 proper nesting
+ * 2. Primary Action Visual Weight - CTA prominence
+ * 3. Visual Grouping Consistency - Card vs section usage
+ * 4. White Space Rhythm - Consistent spacing patterns
+ * 5. Content Density Balance - Information overload detection
+ * 6. Z-Index Layer Hierarchy - Proper stacking context
+ * 7. Font Weight Hierarchy - Bold usage for emphasis
+ * 8. Size Hierarchy - Consistent sizing scales
+ *
+ * Usage:
+ *   pnpm preflight:ui-visual-hierarchy
+ */
+interface Issue {
+    file: string;
+    line: number;
+    type: string;
+    severity: "error" | "warning" | "info";
+    message: string;
+    suggestion: string;
+    snippet?: string;
+}
+interface CheckResult {
+    name: string;
+    passed: boolean;
+    blocking: boolean;
+    issues: Issue[];
+    duration: number;
+}
+interface ModuleResult {
+    module: string;
+    passed: boolean;
+    totalDuration: number;
+    checks: CheckResult[];
+    summary: {
+        total: number;
+        passed: number;
+        failed: number;
+        errors: number;
+        warnings: number;
+    };
+}
+declare class UIVisualHierarchyModule {
+    private verbose;
+    constructor(options?: {
+        verbose?: boolean;
+    });
+    private getTsxFiles;
+    /**
+     * 1. Heading Level Progression
+     */
+    checkHeadingLevelProgression(): Promise<CheckResult>;
+    /**
+     * 2. Primary Action Visual Weight
+     */
+    checkPrimaryActionWeight(): Promise<CheckResult>;
+    /**
+     * 3. Visual Grouping Consistency
+     */
+    checkVisualGroupingConsistency(): Promise<CheckResult>;
+    /**
+     * 4. White Space Rhythm
+     */
+    checkWhiteSpaceRhythm(): Promise<CheckResult>;
+    /**
+     * 5. Content Density Balance
+     */
+    checkContentDensityBalance(): Promise<CheckResult>;
+    /**
+     * 6. Z-Index Layer Hierarchy
+     */
+    checkZIndexHierarchy(): Promise<CheckResult>;
+    /**
+     * 7. Font Weight Hierarchy
+     */
+    checkFontWeightHierarchy(): Promise<CheckResult>;
+    /**
+     * 8. Size Hierarchy
+     */
+    checkSizeHierarchy(): Promise<CheckResult>;
+    runAll(filter?: string): Promise<ModuleResult>;
+}
+export { UIVisualHierarchyModule };
+//# sourceMappingURL=ui-visual-hierarchy.d.ts.map

package/dist/checks/consolidated/ui-visual-hierarchy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-visual-hierarchy.d.ts","sourceRoot":"","sources":["../../../src/checks/consolidated/ui-visual-hierarchy.ts"],"names":[],"mappings":";AACA;;;;;;;;;;;;;;;;;GAiBG;AAOH,UAAU,KAAK;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,IAAI,EAAE,MAAM,CAAC;IACb,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,MAAM,CAAC;IACvC,OAAO,EAAE,MAAM,CAAC;IAChB,UAAU,EAAE,MAAM,CAAC;IACnB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,WAAW;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,OAAO,CAAC;IAChB,QAAQ,EAAE,OAAO,CAAC;IAClB,MAAM,EAAE,KAAK,EAAE,CAAC;IAChB,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED,UAAU,YAAY;IACpB,MAAM,EAAE,MAAM,CAAC;IACf,MAAM,EAAE,OAAO,CAAC;IAChB,aAAa,EAAE,MAAM,CAAC;IACtB,MAAM,EAAE,WAAW,EAAE,CAAC;IACtB,OAAO,EAAE;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAE,CAAC;CAC9F;AAED,cAAM,uBAAuB;IAC3B,OAAO,CAAC,OAAO,CAAU;gBAEb,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO;YAIjC,WAAW;IAIzB;;OAEG;IACG,4BAA4B,IAAI,OAAO,CAAC,WAAW,CAAC;IA4D1D;;OAEG;IACG,wBAAwB,IAAI,OAAO,CAAC,WAAW,CAAC;IAoDtD;;OAEG;IACG,8BAA8B,IAAI,OAAO,CAAC,WAAW,CAAC;IAwD5D;;OAEG;IACG,qBAAqB,IAAI,OAAO,CAAC,WAAW,CAAC;IA8DnD;;OAEG;IACG,0BAA0B,IAAI,OAAO,CAAC,WAAW,CAAC;IAoDxD;;OAEG;IACG,oBAAoB,IAAI,OAAO,CAAC,WAAW,CAAC;IA8DlD;;OAEG;IACG,wBAAwB,IAAI,OAAO,CAAC,WAAW,CAAC;IAmDtD;;OAEG;IACG,kBAAkB,IAAI,OAAO,CAAC,WAAW,CAAC;IAkE1C,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;CAwCrD;AA2CD,OAAO,EAAE,uBAAuB,EAAE,CAAC"}

package/dist/checks/consolidated/ui-visual-hierarchy.js

@@ -0,0 +1,562 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * UI Visual Hierarchy Preflight (NON-BLOCKING)
+ *
+ * Validates visual hierarchy and content prioritization.
+ *
+ * Checks:
+ * 1. Heading Level Progression - h1→h2→h3 proper nesting
+ * 2. Primary Action Visual Weight - CTA prominence
+ * 3. Visual Grouping Consistency - Card vs section usage
+ * 4. White Space Rhythm - Consistent spacing patterns
+ * 5. Content Density Balance - Information overload detection
+ * 6. Z-Index Layer Hierarchy - Proper stacking context
+ * 7. Font Weight Hierarchy - Bold usage for emphasis
+ * 8. Size Hierarchy - Consistent sizing scales
+ *
+ * Usage:
+ *   pnpm preflight:ui-visual-hierarchy
+ */
+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.UIVisualHierarchyModule = 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");
+class UIVisualHierarchyModule {
+    verbose;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+    }
+    async getTsxFiles() {
+        return file_cache_1.fileCache.getAppAndComponentsTSX();
+    }
+    /**
+     * 1. Heading Level Progression
+     */
+    async checkHeadingLevelProgression() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            const headingLevels = [];
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for h1-h6 tags
+                const headingMatch = line.match(/<h([1-6])\b/);
+                if (headingMatch) {
+                    const level = parseInt(headingMatch[1]);
+                    const lastLevel = headingLevels.length > 0 ? headingLevels[headingLevels.length - 1] : 0;
+                    // Check for skipped levels (h1 → h3)
+                    if (level > lastLevel + 1 && lastLevel > 0) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "skipped-heading-level",
+                            severity: "warning",
+                            message: `Skipped heading level: h${lastLevel} → h${level}`,
+                            suggestion: `Use h${lastLevel + 1} instead for proper document outline`,
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    headingLevels.push(level);
+                }
+            }
+            // Check for multiple h1s
+            const h1Count = headingLevels.filter((l) => l === 1).length;
+            if (h1Count > 1) {
+                issues.push({
+                    file,
+                    line: 1,
+                    type: "multiple-h1",
+                    severity: "info",
+                    message: `${h1Count} h1 headings found - should typically have one per page`,
+                    suggestion: "Use h1 for main page title only, h2 for sections",
+                });
+            }
+        }
+        return {
+            name: "Heading Level Progression",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 2. Primary Action Visual Weight
+     */
+    async checkPrimaryActionWeight() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            let primaryButtonCount = 0;
+            let secondaryButtonCount = 0;
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Count primary vs secondary buttons
+                if (/variant=["'](?:default|primary)["']|<Button(?![^>]*variant)/.test(line)) {
+                    primaryButtonCount++;
+                }
+                if (/variant=["'](?:secondary|outline|ghost)["']/.test(line)) {
+                    secondaryButtonCount++;
+                }
+                // Check for multiple primary actions in same area
+                if (/ButtonGroup|button.*group|actions|cta/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 15, lines.length)).join("\n");
+                    const primaryInGroup = (contextBlock.match(/variant=["'](?:default|primary)["']/g) || []).length;
+                    if (primaryInGroup > 1) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "multiple-primary-actions",
+                            severity: "info",
+                            message: `${primaryInGroup} primary buttons in action group`,
+                            suggestion: "Use one primary action, others should be secondary/outline",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Primary Action Weight",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 3. Visual Grouping Consistency
+     */
+    async checkVisualGroupingConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const groupingPatterns = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Track grouping patterns
+                if (/<Card\b/.test(line)) {
+                    groupingPatterns.set("Card", (groupingPatterns.get("Card") || 0) + 1);
+                }
+                if (/<Section\b/.test(line)) {
+                    groupingPatterns.set("Section", (groupingPatterns.get("Section") || 0) + 1);
+                }
+                if (/border.*rounded|rounded.*border/.test(line) && !/<Card/.test(line)) {
+                    groupingPatterns.set("div-with-border", (groupingPatterns.get("div-with-border") || 0) + 1);
+                }
+                // Check for inconsistent grouping in lists
+                if (/\.map\s*\(/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 20, lines.length)).join("\n");
+                    const hasCard = /<Card/.test(contextBlock);
+                    const hasBorderedDiv = /border.*rounded|rounded.*border/.test(contextBlock) && !/<Card/.test(contextBlock);
+                    if (hasCard && hasBorderedDiv) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "mixed-grouping-in-list",
+                            severity: "info",
+                            message: "List items mix Card and bordered div patterns",
+                            suggestion: "Use consistent grouping: all Cards or all simple containers",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Visual Grouping Consistency",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 4. White Space Rhythm
+     */
+    async checkWhiteSpaceRhythm() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const spacingPatterns = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Track section spacing patterns
+                if (/space-y-(\d+)|gap-(\d+)|mb-(\d+)|mt-(\d+)/.test(line)) {
+                    const matches = line.match(/(?:space-y-|gap-|mb-|mt-)(\d+)/g) || [];
+                    for (const match of matches) {
+                        spacingPatterns.set(match, (spacingPatterns.get(match) || 0) + 1);
+                    }
+                }
+                // Check for arbitrary spacing values
+                if (/space-y-\[|gap-\[|m[tblrxy]-\[/.test(line)) {
+                    const match = line.match(/(?:space-y-|gap-|m[tblrxy]-)\[([^\]]+)\]/);
+                    if (match) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "arbitrary-spacing",
+                            severity: "info",
+                            message: `Arbitrary spacing value: ${match[0]}`,
+                            suggestion: "Use design system spacing tokens (4, 6, 8, 12, 16)",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        // Check for too many spacing variations
+        if (spacingPatterns.size > 8) {
+            const sorted = [...spacingPatterns.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "too-many-spacing-values",
+                severity: "info",
+                message: `${spacingPatterns.size} different spacing patterns in use`,
+                suggestion: "Standardize on fewer spacing values for visual rhythm",
+            });
+        }
+        return {
+            name: "White Space Rhythm",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 5. Content Density Balance
+     */
+    async checkContentDensityBalance() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for dense grid layouts
+                if (/grid-cols-(\d+)|grid.*cols.*(\d+)/.test(line)) {
+                    const match = line.match(/grid-cols-(\d+)/);
+                    if (match && parseInt(match[1]) > 4) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "dense-grid",
+                            severity: "info",
+                            message: `Grid with ${match[1]} columns may be too dense`,
+                            suggestion: "Consider fewer columns or responsive breakpoints",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for cramped padding
+                if (/<Card[^>]*p-1|<Card[^>]*p-2/.test(line)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "cramped-card-padding",
+                        severity: "info",
+                        message: "Card with minimal padding may feel cramped",
+                        suggestion: "Use p-4 or p-6 for comfortable card padding",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            }
+        }
+        return {
+            name: "Content Density Balance",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 6. Z-Index Layer Hierarchy
+     */
+    async checkZIndexHierarchy() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const zIndexValues = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Track z-index values
+                const zMatch = line.match(/z-(\d+)|z-\[(\d+)\]|zIndex:\s*(\d+)/);
+                if (zMatch) {
+                    const value = zMatch[1] || zMatch[2] || zMatch[3];
+                    if (!zIndexValues.has(value)) {
+                        zIndexValues.set(value, []);
+                    }
+                    zIndexValues.get(value).push({ file, line: i + 1 });
+                }
+                // Check for very high z-index values
+                if (/z-\[9999\]|z-\[999\]|zIndex:\s*9999/.test(line)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "excessive-z-index",
+                        severity: "warning",
+                        message: "Excessively high z-index value",
+                        suggestion: "Use structured z-index scale (10, 20, 30, 40, 50)",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            }
+        }
+        // Check for z-index collisions
+        for (const [value, locations] of zIndexValues.entries()) {
+            if (locations.length > 3 && parseInt(value) > 10) {
+                issues.push({
+                    file: "codebase-wide",
+                    line: 0,
+                    type: "z-index-collision-risk",
+                    severity: "info",
+                    message: `z-${value} used ${locations.length} times - potential stacking issues`,
+                    suggestion: "Use semantic z-index tokens (z-dropdown, z-modal, z-tooltip)",
+                });
+            }
+        }
+        return {
+            name: "Z-Index Layer Hierarchy",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 7. Font Weight Hierarchy
+     */
+    async checkFontWeightHierarchy() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const fontWeightPatterns = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Track font weight usage
+                if (/font-(?:normal|medium|semibold|bold|extrabold)/.test(line)) {
+                    const match = line.match(/font-(normal|medium|semibold|bold|extrabold)/);
+                    if (match) {
+                        fontWeightPatterns.set(match[1], (fontWeightPatterns.get(match[1]) || 0) + 1);
+                    }
+                }
+                // Check for excessive bold usage
+                if (/font-bold/.test(line)) {
+                    const contextBlock = lines.slice(Math.max(0, i - 5), Math.min(i + 5, lines.length)).join("\n");
+                    const boldCount = (contextBlock.match(/font-bold/g) || []).length;
+                    if (boldCount > 3) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "excessive-bold",
+                            severity: "info",
+                            message: "Multiple bold elements in close proximity",
+                            suggestion: "Use bold sparingly for emphasis - everything bold = nothing bold",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Font Weight Hierarchy",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 8. Size Hierarchy
+     */
+    async checkSizeHierarchy() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const textSizePatterns = new Map();
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Track text size usage
+                if (/text-(?:xs|sm|base|lg|xl|2xl|3xl|4xl)/.test(line)) {
+                    const match = line.match(/text-(xs|sm|base|lg|xl|2xl|3xl|4xl)/);
+                    if (match) {
+                        textSizePatterns.set(match[1], (textSizePatterns.get(match[1]) || 0) + 1);
+                    }
+                }
+                // Check for arbitrary text sizes
+                if (/text-\[\d+px\]|text-\[\d+rem\]/.test(line)) {
+                    const match = line.match(/text-\[([^\]]+)\]/);
+                    if (match) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "arbitrary-text-size",
+                            severity: "info",
+                            message: `Arbitrary text size: text-[${match[1]}]`,
+                            suggestion: "Use design system text sizes (text-sm, text-base, text-lg)",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        // Check for proper size distribution
+        if (textSizePatterns.size > 0) {
+            const total = [...textSizePatterns.values()].reduce((a, b) => a + b, 0);
+            const baseUsage = textSizePatterns.get("base") || 0;
+            if (baseUsage < total * 0.3) {
+                issues.push({
+                    file: "codebase-wide",
+                    line: 0,
+                    type: "low-base-text-usage",
+                    severity: "info",
+                    message: "Base text size used sparingly - may indicate size inconsistency",
+                    suggestion: "text-base should be the most common size for body content",
+                });
+            }
+        }
+        return {
+            name: "Size Hierarchy",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    async runAll(filter) {
+        const startTime = Date.now();
+        const checks = [];
+        const checkMap = {
+            heading: () => this.checkHeadingLevelProgression(),
+            action: () => this.checkPrimaryActionWeight(),
+            grouping: () => this.checkVisualGroupingConsistency(),
+            whitespace: () => this.checkWhiteSpaceRhythm(),
+            density: () => this.checkContentDensityBalance(),
+            zindex: () => this.checkZIndexHierarchy(),
+            fontweight: () => this.checkFontWeightHierarchy(),
+            size: () => this.checkSizeHierarchy(),
+        };
+        if (filter && checkMap[filter]) {
+            checks.push(await checkMap[filter]());
+        }
+        else {
+            for (const check of Object.values(checkMap)) {
+                checks.push(await check());
+            }
+        }
+        const errors = checks.reduce((sum, c) => sum + c.issues.filter((i) => i.severity === "error").length, 0);
+        const warnings = checks.reduce((sum, c) => sum + c.issues.filter((i) => i.severity === "warning").length, 0);
+        return {
+            module: "UI Visual Hierarchy",
+            passed: errors === 0,
+            totalDuration: Date.now() - startTime,
+            checks,
+            summary: {
+                total: checks.length,
+                passed: checks.filter((c) => c.passed).length,
+                failed: checks.filter((c) => !c.passed).length,
+                errors,
+                warnings,
+            },
+        };
+    }
+}
+exports.UIVisualHierarchyModule = UIVisualHierarchyModule;
+async function main() {
+    const args = process.argv.slice(2);
+    const filter = args.find((a) => !a.startsWith("-"));
+    const verbose = args.includes("--verbose") || args.includes("-v");
+    const module = new UIVisualHierarchyModule({ verbose });
+    const result = await module.runAll(filter);
+    console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    console.log(`${console_chars_1.emoji.palette} UI VISUAL HIERARCHY CHECK`);
+    console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    console.log();
+    for (const check of result.checks) {
+        const icon = check.passed ? console_chars_1.emoji.success : check.issues.some((i) => i.severity === "error") ? console_chars_1.emoji.error : console_chars_1.emoji.warning;
+        console.log(`${icon} ${check.name} (${check.duration}ms)`);
+        if (check.issues.length > 0 && (verbose || check.issues.some((i) => i.severity !== "info"))) {
+            for (const issue of check.issues.slice(0, verbose ? 100 : 5)) {
+                const sevIcon = issue.severity === "error" ? console_chars_1.emoji.error : issue.severity === "warning" ? console_chars_1.emoji.warning : console_chars_1.emoji.info;
+                const relPath = path.relative(process.cwd(), issue.file).replace(/\\/g, "/");
+                console.log(`  ${sevIcon} ${relPath}:${issue.line}`);
+                console.log(`     ${issue.message}`);
+                console.log(`     ${console_chars_1.emoji.hint} ${issue.suggestion}`);
+            }
+            if (!verbose && check.issues.length > 5) {
+                console.log(`  ... and ${check.issues.length - 5} more issues`);
+            }
+        }
+        console.log();
+    }
+    console.log((0, console_chars_1.createDivider)(80, "light"));
+    console.log(`Total: ${result.summary.total} checks | ${console_chars_1.emoji.error} ${result.summary.errors} errors | ${console_chars_1.emoji.warning} ${result.summary.warnings} warnings`);
+    console.log(`Duration: ${(result.totalDuration / 1000).toFixed(2)}s`);
+    console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    process.exit(result.summary.errors > 0 ? 1 : 0);
+}
+if (require.main === module)
+    main();
+//# sourceMappingURL=ui-visual-hierarchy.js.map