@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/consolidated/ui-gradient-shadow.d.ts

@@ -0,0 +1,90 @@
+#!/usr/bin/env tsx
+/**
+ * UI Gradient & Shadow Preflight (NON-BLOCKING)
+ *
+ * Validates gradient and shadow usage for consistency.
+ *
+ * Checks:
+ * 1. Shadow Token Compliance - Use design tokens
+ * 2. Gradient Direction Consistency - Consistent angles
+ * 3. Hover Shadow Elevation - Proper lift effect
+ * 4. Focus Ring Shadow - Consistent focus styling
+ * 5. Card Elevation Hierarchy - Shadow layering
+ * 6. Dark Mode Shadows - Proper dark theme handling
+ * 7. Arbitrary Shadow Values - Custom shadow detection
+ * 8. Gradient Color Stops - Proper gradient structure
+ *
+ * Usage:
+ *   pnpm preflight:ui-gradient-shadow
+ */
+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 UIGradientShadowModule {
+    private verbose;
+    constructor(options?: {
+        verbose?: boolean;
+    });
+    private getTsxFiles;
+    /**
+     * 1. Shadow Token Compliance
+     */
+    checkShadowTokenCompliance(): Promise<CheckResult>;
+    /**
+     * 2. Gradient Direction Consistency
+     */
+    checkGradientDirectionConsistency(): Promise<CheckResult>;
+    /**
+     * 3. Hover Shadow Elevation
+     */
+    checkHoverShadowElevation(): Promise<CheckResult>;
+    /**
+     * 4. Focus Ring Shadow
+     */
+    checkFocusRingShadow(): Promise<CheckResult>;
+    /**
+     * 5. Card Elevation Hierarchy
+     */
+    checkCardElevationHierarchy(): Promise<CheckResult>;
+    /**
+     * 6. Dark Mode Shadows
+     */
+    checkDarkModeShadows(): Promise<CheckResult>;
+    /**
+     * 7. Arbitrary Shadow Values
+     */
+    checkArbitraryShadowValues(): Promise<CheckResult>;
+    /**
+     * 8. Gradient Color Stops
+     */
+    checkGradientColorStops(): Promise<CheckResult>;
+    runAll(filter?: string): Promise<ModuleResult>;
+}
+export { UIGradientShadowModule };
+//# sourceMappingURL=ui-gradient-shadow.d.ts.map

package/dist/checks/consolidated/ui-gradient-shadow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ui-gradient-shadow.d.ts","sourceRoot":"","sources":["../../../src/checks/consolidated/ui-gradient-shadow.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,sBAAsB;IAC1B,OAAO,CAAC,OAAO,CAAU;gBAEb,OAAO,GAAE;QAAE,OAAO,CAAC,EAAE,OAAO,CAAA;KAAO;YAIjC,WAAW;IAIzB;;OAEG;IACG,0BAA0B,IAAI,OAAO,CAAC,WAAW,CAAC;IA+DxD;;OAEG;IACG,iCAAiC,IAAI,OAAO,CAAC,WAAW,CAAC;IAgE/D;;OAEG;IACG,yBAAyB,IAAI,OAAO,CAAC,WAAW,CAAC;IA4DvD;;OAEG;IACG,oBAAoB,IAAI,OAAO,CAAC,WAAW,CAAC;IA2DlD;;OAEG;IACG,2BAA2B,IAAI,OAAO,CAAC,WAAW,CAAC;IAuDzD;;OAEG;IACG,oBAAoB,IAAI,OAAO,CAAC,WAAW,CAAC;IA4DlD;;OAEG;IACG,0BAA0B,IAAI,OAAO,CAAC,WAAW,CAAC;IAiDxD;;OAEG;IACG,uBAAuB,IAAI,OAAO,CAAC,WAAW,CAAC;IAwD/C,MAAM,CAAC,MAAM,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,YAAY,CAAC;CAwCrD;AA2CD,OAAO,EAAE,sBAAsB,EAAE,CAAC"}

package/dist/checks/consolidated/ui-gradient-shadow.js

@@ -0,0 +1,568 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * UI Gradient & Shadow Preflight (NON-BLOCKING)
+ *
+ * Validates gradient and shadow usage for consistency.
+ *
+ * Checks:
+ * 1. Shadow Token Compliance - Use design tokens
+ * 2. Gradient Direction Consistency - Consistent angles
+ * 3. Hover Shadow Elevation - Proper lift effect
+ * 4. Focus Ring Shadow - Consistent focus styling
+ * 5. Card Elevation Hierarchy - Shadow layering
+ * 6. Dark Mode Shadows - Proper dark theme handling
+ * 7. Arbitrary Shadow Values - Custom shadow detection
+ * 8. Gradient Color Stops - Proper gradient structure
+ *
+ * Usage:
+ *   pnpm preflight:ui-gradient-shadow
+ */
+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.UIGradientShadowModule = 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 UIGradientShadowModule {
+    verbose;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+    }
+    async getTsxFiles() {
+        return file_cache_1.fileCache.getAppAndComponentsTSX();
+    }
+    /**
+     * 1. Shadow Token Compliance
+     */
+    async checkShadowTokenCompliance() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const shadowPatterns = new Map();
+        const standardShadows = ["shadow-sm", "shadow", "shadow-md", "shadow-lg", "shadow-xl", "shadow-2xl", "shadow-none", "shadow-inner"];
+        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 shadow class usage
+                const shadowMatches = line.match(/shadow(?:-[a-z0-9]+)?/g) || [];
+                for (const match of shadowMatches) {
+                    if (!match.includes("[")) {
+                        shadowPatterns.set(match, (shadowPatterns.get(match) || 0) + 1);
+                    }
+                }
+                // Check for arbitrary shadow values
+                if (/shadow-\[/.test(line)) {
+                    const match = line.match(/shadow-\[([^\]]+)\]/);
+                    if (match) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "arbitrary-shadow",
+                            severity: "info",
+                            message: `Arbitrary shadow value: shadow-[${match[1].substring(0, 30)}...]`,
+                            suggestion: "Use design system shadows: shadow-sm, shadow-md, shadow-lg",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for inline box-shadow
+                if (/style=.*box-shadow|boxShadow/.test(line)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "inline-shadow",
+                        severity: "info",
+                        message: "Inline style box-shadow instead of Tailwind class",
+                        suggestion: "Use shadow-* Tailwind classes for consistency",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            }
+        }
+        return {
+            name: "Shadow Token Compliance",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 2. Gradient Direction Consistency
+     */
+    async checkGradientDirectionConsistency() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const gradientDirections = 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 gradient directions
+                const directionMatch = line.match(/bg-gradient-to-(t|tr|r|br|b|bl|l|tl)/);
+                if (directionMatch) {
+                    gradientDirections.set(directionMatch[1], (gradientDirections.get(directionMatch[1]) || 0) + 1);
+                }
+                // Check for arbitrary gradient angles
+                if (/bg-\[linear-gradient\((\d+)deg/.test(line)) {
+                    const angleMatch = line.match(/linear-gradient\((\d+)deg/);
+                    if (angleMatch) {
+                        const angle = parseInt(angleMatch[1]);
+                        // Check for non-standard angles
+                        if (angle % 45 !== 0) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "non-standard-gradient-angle",
+                                severity: "info",
+                                message: `Non-standard gradient angle: ${angle}deg`,
+                                suggestion: "Use standard angles (0, 45, 90, 135, 180, etc.) for consistency",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                }
+            }
+        }
+        // Check for too many gradient directions
+        if (gradientDirections.size > 4) {
+            const sorted = [...gradientDirections.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "many-gradient-directions",
+                severity: "info",
+                message: `${gradientDirections.size} gradient directions: ${sorted.map(([d, c]) => `to-${d}(${c})`).join(", ")}`,
+                suggestion: "Standardize on 2-3 gradient directions for visual consistency",
+            });
+        }
+        return {
+            name: "Gradient Direction Consistency",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 3. Hover Shadow Elevation
+     */
+    async checkHoverShadowElevation() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const hoverShadowPatterns = 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 hover shadow patterns
+                if (/hover:shadow-/.test(line)) {
+                    const match = line.match(/hover:(shadow-[a-z0-9]+)/);
+                    if (match) {
+                        hoverShadowPatterns.set(match[1], (hoverShadowPatterns.get(match[1]) || 0) + 1);
+                    }
+                    // Check for hover with transition
+                    const hasTransition = /transition/.test(line);
+                    if (!hasTransition) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "hover-shadow-no-transition",
+                            severity: "info",
+                            message: "Hover shadow without transition",
+                            suggestion: "Add transition-shadow for smooth elevation change",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for extreme shadow jumps
+                if (/shadow(?:-sm)?.*hover:shadow-2xl|shadow.*hover:shadow-xl/.test(line)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "extreme-shadow-jump",
+                        severity: "info",
+                        message: "Large shadow jump on hover may be too dramatic",
+                        suggestion: "Use gradual elevation: shadow -> shadow-md -> shadow-lg",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            }
+        }
+        return {
+            name: "Hover Shadow Elevation",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 4. Focus Ring Shadow
+     */
+    async checkFocusRingShadow() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const focusRingPatterns = 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 focus ring patterns
+                if (/focus:ring|focus-visible:ring/.test(line)) {
+                    const match = line.match(/focus(?:-visible)?:(ring(?:-[a-z0-9]+)?)/);
+                    if (match) {
+                        focusRingPatterns.set(match[1], (focusRingPatterns.get(match[1]) || 0) + 1);
+                    }
+                }
+                // Check for focus-visible vs focus
+                if (/focus:ring(?!.*focus-visible)/.test(line) && /<(?:Button|button|Input|input|a)\b/.test(line)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "focus-instead-of-focus-visible",
+                        severity: "info",
+                        message: "Using focus: instead of focus-visible: for interactive element",
+                        suggestion: "Use focus-visible: to show ring only for keyboard navigation",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            }
+        }
+        // Check for inconsistent focus rings
+        if (focusRingPatterns.size > 3) {
+            const sorted = [...focusRingPatterns.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "inconsistent-focus-rings",
+                severity: "warning",
+                message: `${focusRingPatterns.size} focus ring variations: ${sorted.map(([r, c]) => `${r}(${c})`).join(", ")}`,
+                suggestion: "Standardize focus ring style for accessibility consistency",
+            });
+        }
+        return {
+            name: "Focus Ring Shadow",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 5. Card Elevation Hierarchy
+     */
+    async checkCardElevationHierarchy() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const cardShadows = 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 Card shadows
+                if (/<Card\b/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    const shadowMatch = contextBlock.match(/shadow(?:-[a-z0-9]+)?/);
+                    if (shadowMatch) {
+                        cardShadows.set(shadowMatch[0], (cardShadows.get(shadowMatch[0]) || 0) + 1);
+                    }
+                    else {
+                        cardShadows.set("no-shadow", (cardShadows.get("no-shadow") || 0) + 1);
+                    }
+                }
+                // Check for nested cards with same elevation
+                if (/<Card\b.*shadow-/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 20, lines.length)).join("\n");
+                    const shadowMatches = contextBlock.match(/shadow-(?:sm|md|lg|xl)/g) || [];
+                    if (shadowMatches.length > 1 && new Set(shadowMatches).size === 1) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "nested-same-elevation",
+                            severity: "info",
+                            message: "Nested cards with same shadow elevation",
+                            suggestion: "Inner cards should have lower elevation than outer containers",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Card Elevation Hierarchy",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 6. Dark Mode Shadows
+     */
+    async checkDarkModeShadows() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        let hasDarkModeShadows = false;
+        let totalShadowElements = 0;
+        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];
+                // Count shadow usage
+                if (/\bshadow(?:-[a-z]+)?\b/.test(line) && !/shadow-none/.test(line)) {
+                    totalShadowElements++;
+                    // Check for dark mode shadow handling
+                    if (/dark:shadow/.test(line)) {
+                        hasDarkModeShadows = true;
+                    }
+                }
+            }
+        }
+        // Check if dark mode is used but shadows aren't adjusted
+        if (totalShadowElements > 10 && !hasDarkModeShadows) {
+            // Check if dark mode is used at all
+            let hasDarkMode = false;
+            for (const file of files) {
+                const content = fs.readFileSync(file, "utf8");
+                if (/dark:/.test(content)) {
+                    hasDarkMode = true;
+                    break;
+                }
+            }
+            if (hasDarkMode) {
+                issues.push({
+                    file: "codebase-wide",
+                    line: 0,
+                    type: "no-dark-mode-shadows",
+                    severity: "info",
+                    message: "Dark mode used but no dark:shadow classes found",
+                    suggestion: "Consider reducing shadow intensity in dark mode (dark:shadow-sm)",
+                });
+            }
+        }
+        return {
+            name: "Dark Mode Shadows",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 7. Arbitrary Shadow Values
+     */
+    async checkArbitraryShadowValues() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const arbitraryShadows = 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];
+                // Check for arbitrary shadow values
+                const arbitraryMatch = line.match(/shadow-\[([^\]]+)\]/);
+                if (arbitraryMatch) {
+                    const value = arbitraryMatch[1].substring(0, 50);
+                    arbitraryShadows.set(value, (arbitraryShadows.get(value) || 0) + 1);
+                }
+                // Check for CSS variable shadows
+                if (/shadow-\[var\(--/.test(line)) {
+                    // This is actually good practice
+                }
+            }
+        }
+        if (arbitraryShadows.size > 3) {
+            const sorted = [...arbitraryShadows.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "many-arbitrary-shadows",
+                severity: "info",
+                message: `${arbitraryShadows.size} arbitrary shadow values`,
+                suggestion: "Consider adding frequently used shadows to Tailwind config",
+            });
+        }
+        return {
+            name: "Arbitrary Shadow Values",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 8. Gradient Color Stops
+     */
+    async checkGradientColorStops() {
+        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 gradients with color stops
+                if (/bg-gradient-to-/.test(line)) {
+                    const hasFrom = /from-/.test(line);
+                    const hasTo = /to-(?!t|tr|r|br|b|bl|l|tl)/.test(line);
+                    const hasVia = /via-/.test(line);
+                    if (hasFrom && !hasTo) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "gradient-missing-to",
+                            severity: "warning",
+                            message: "Gradient with from- but missing to- color stop",
+                            suggestion: "Add to-* color for complete gradient (e.g., from-blue-500 to-purple-500)",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                    // Check for too many color stops
+                    const colorStops = (line.match(/(?:from|via|to)-[a-z]+-\d+/g) || []).length;
+                    if (colorStops > 3) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "too-many-gradient-stops",
+                            severity: "info",
+                            message: `Gradient with ${colorStops} color stops may be complex`,
+                            suggestion: "Keep gradients simple: 2-3 color stops maximum",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        return {
+            name: "Gradient Color Stops",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    async runAll(filter) {
+        const startTime = Date.now();
+        const checks = [];
+        const checkMap = {
+            shadow: () => this.checkShadowTokenCompliance(),
+            gradient: () => this.checkGradientDirectionConsistency(),
+            hover: () => this.checkHoverShadowElevation(),
+            focus: () => this.checkFocusRingShadow(),
+            elevation: () => this.checkCardElevationHierarchy(),
+            dark: () => this.checkDarkModeShadows(),
+            arbitrary: () => this.checkArbitraryShadowValues(),
+            stops: () => this.checkGradientColorStops(),
+        };
+        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 Gradient & Shadow",
+            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.UIGradientShadowModule = UIGradientShadowModule;
+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 UIGradientShadowModule({ verbose });
+    const result = await module.runAll(filter);
+    console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    console.log(`${console_chars_1.emoji.palette} UI GRADIENT & SHADOW 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-gradient-shadow.js.map