@empline/preflight 1.1.11 → 1.1.13

package/dist/checks/consolidated/ui-data-display.js

@@ -0,0 +1,740 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * UI Data Display Preflight (NON-BLOCKING)
+ *
+ * Validates data presentation consistency across the application.
+ * Ensures numbers, dates, currencies, and text are formatted uniformly.
+ *
+ * Checks:
+ * 1. Number Formatting - Locale-aware number display
+ * 2. Currency Display - Consistent currency formatting
+ * 3. Date/Time Formatting - Consistent date display patterns
+ * 4. Percentage Display - 0.5 vs 50% consistency
+ * 5. Large Number Abbreviation - K, M, B patterns
+ * 6. Truncation Patterns - Ellipsis handling
+ * 7. Empty/Null Placeholders - Consistent N/A, — usage
+ * 8. Decimal Precision - Consistent decimal places
+ *
+ * Usage:
+ *   pnpm preflight:ui-data-display              # All checks
+ *   pnpm preflight:ui-data-display numbers      # Number formatting 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.UIDataDisplayModule = 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 UIDataDisplayModule {
+    verbose;
+    constructor(options = {}) {
+        this.verbose = options.verbose || false;
+    }
+    async getTsxFiles() {
+        return file_cache_1.fileCache.getAppAndComponentsTSX();
+    }
+    /**
+     * 1. Number Formatting
+     * Check for consistent number formatting with locale support
+     */
+    async checkNumberFormatting() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const numberFormatPatterns = new Map();
+        let hasIntlNumberFormat = false;
+        let hasToLocaleString = false;
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            if (/Intl\.NumberFormat/.test(content)) {
+                hasIntlNumberFormat = true;
+            }
+            if (/\.toLocaleString\(/.test(content)) {
+                hasToLocaleString = true;
+            }
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for raw number display without formatting
+                if (/\{[\s]*(?:item|data|row|record)\.(?:count|quantity|amount|total|price|value)[\s]*\}/.test(line)) {
+                    const contextBlock = lines.slice(Math.max(0, i - 3), Math.min(i + 3, lines.length)).join("\n");
+                    const hasFormatting = /toLocaleString|NumberFormat|formatNumber|formatCurrency|Intl\./i.test(contextBlock);
+                    if (!hasFormatting) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "unformatted-number",
+                            severity: "info",
+                            message: "Number displayed without locale formatting",
+                            suggestion: "Use .toLocaleString() or Intl.NumberFormat for consistent number display",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for manual comma insertion (anti-pattern)
+                if (/\.replace\([^)]*,.*,/i.test(line) && /\d/.test(line)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "manual-number-formatting",
+                        severity: "info",
+                        message: "Manual number formatting detected - may not be locale-aware",
+                        suggestion: "Use Intl.NumberFormat for locale-aware formatting",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Track formatting patterns used
+                if (/toLocaleString\(['"]([^'"]+)/.test(line)) {
+                    const match = line.match(/toLocaleString\(['"]([^'"]+)/);
+                    if (match) {
+                        numberFormatPatterns.set(match[1], (numberFormatPatterns.get(match[1]) || 0) + 1);
+                    }
+                }
+            }
+        }
+        // Check for inconsistent locale usage
+        if (numberFormatPatterns.size > 1) {
+            const sorted = [...numberFormatPatterns.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "inconsistent-number-locale",
+                severity: "warning",
+                message: `Multiple number locales in use: ${sorted.map(([l, c]) => `${l}(${c})`).join(", ")}`,
+                suggestion: "Standardize on a single locale or use user's locale consistently",
+            });
+        }
+        return {
+            name: "Number Formatting",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 2. Currency Display
+     * Check for consistent currency formatting
+     */
+    async checkCurrencyDisplay() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const currencyPatterns = new Map();
+        let hasCurrencyFormatter = false;
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            if (/style:\s*['"]currency|formatCurrency|Intl\.NumberFormat.*currency/i.test(content)) {
+                hasCurrencyFormatter = true;
+            }
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for hardcoded $ without proper formatting
+                if (/\$\{.*\}|\$\s*\d|\{\s*['"]\$/.test(line)) {
+                    const contextBlock = lines.slice(Math.max(0, i - 2), Math.min(i + 2, lines.length)).join("\n");
+                    // Skip if it's a template literal for something else
+                    if (/formatCurrency|toLocaleString|NumberFormat/.test(contextBlock))
+                        continue;
+                    // Check if it's actually a price display
+                    if (/price|cost|amount|total|fee|charge/i.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "hardcoded-currency-symbol",
+                            severity: "info",
+                            message: "Hardcoded $ symbol - may not work for other currencies",
+                            suggestion: "Use Intl.NumberFormat with style: 'currency' for proper formatting",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Check for cents handling
+                if (/\/\s*100|\*\s*100|cents|Cents/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 5, lines.length)).join("\n");
+                    const hasProperConversion = /toFixed|Math\.round|NumberFormat/.test(contextBlock);
+                    if (!hasProperConversion) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "cents-conversion-risk",
+                            severity: "info",
+                            message: "Cents conversion without rounding may cause floating point errors",
+                            suggestion: "Use Math.round() or toFixed(2) when converting cents to dollars",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+                // Track currency format patterns
+                if (/\.toFixed\((\d)\)/.test(line)) {
+                    const match = line.match(/\.toFixed\((\d)\)/);
+                    if (match) {
+                        currencyPatterns.set(`toFixed(${match[1]})`, (currencyPatterns.get(`toFixed(${match[1]})`) || 0) + 1);
+                    }
+                }
+            }
+        }
+        // Check for inconsistent decimal places
+        if (currencyPatterns.size > 1) {
+            const sorted = [...currencyPatterns.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "inconsistent-decimal-places",
+                severity: "info",
+                message: `Multiple decimal patterns: ${sorted.map(([p, c]) => `${p}(${c})`).join(", ")}`,
+                suggestion: "Standardize decimal places for currency (usually 2)",
+            });
+        }
+        return {
+            name: "Currency Display",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 3. Date/Time Formatting
+     * Check for consistent date display patterns
+     */
+    async checkDateTimeFormatting() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const dateFormatPatterns = new Map();
+        let hasDateFormatter = false;
+        let hasRelativeTime = false;
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            if (/Intl\.DateTimeFormat|formatDate|date-fns|dayjs|moment/i.test(content)) {
+                hasDateFormatter = true;
+            }
+            if (/RelativeTimeFormat|formatRelative|fromNow|timeAgo/i.test(content)) {
+                hasRelativeTime = true;
+            }
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for raw Date.toString() usage
+                if (/\.toString\(\)/.test(line) && /date|Date|time|Time/i.test(line)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "raw-date-tostring",
+                        severity: "warning",
+                        message: "Date.toString() produces inconsistent output across locales",
+                        suggestion: "Use Intl.DateTimeFormat or date-fns for consistent formatting",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+                // Check for toLocaleDateString with inconsistent options
+                if (/toLocaleDateString\(/.test(line)) {
+                    const match = line.match(/toLocaleDateString\([^)]*\)/);
+                    if (match) {
+                        dateFormatPatterns.set("toLocaleDateString", (dateFormatPatterns.get("toLocaleDateString") || 0) + 1);
+                    }
+                }
+                // Check for date-fns format strings
+                if (/format\([^,]+,\s*['"]([^'"]+)['"]\)/.test(line)) {
+                    const match = line.match(/format\([^,]+,\s*['"]([^'"]+)['"]\)/);
+                    if (match) {
+                        dateFormatPatterns.set(match[1], (dateFormatPatterns.get(match[1]) || 0) + 1);
+                    }
+                }
+                // Check for manual date string building
+                if (/getMonth\(\)|getDate\(\)|getFullYear\(\)/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 3, lines.length)).join("\n");
+                    if (/\+\s*['"]\/['"]|\+\s*['"]-['"]/.test(contextBlock)) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "manual-date-formatting",
+                            severity: "info",
+                            message: "Manual date string building - consider using formatter",
+                            suggestion: "Use Intl.DateTimeFormat or date-fns for maintainable date formatting",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        // Check for too many date format patterns
+        if (dateFormatPatterns.size > 4) {
+            const sorted = [...dateFormatPatterns.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "many-date-formats",
+                severity: "info",
+                message: `${dateFormatPatterns.size} different date formats in use`,
+                suggestion: "Standardize on 2-3 date formats (short, long, relative)",
+            });
+        }
+        return {
+            name: "Date/Time Formatting",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 4. Percentage Display
+     * Check for consistent percentage formatting
+     */
+    async checkPercentageDisplay() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const percentPatterns = 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 percentage display patterns
+                if (/%/.test(line) && /\{.*\}/.test(line)) {
+                    // Check for * 100 pattern
+                    if (/\*\s*100\s*\}?\s*%/.test(line)) {
+                        percentPatterns.set("multiply-100", (percentPatterns.get("multiply-100") || 0) + 1);
+                    }
+                    // Check for direct percentage (already 0-100)
+                    else if (/\}\s*%/.test(line)) {
+                        percentPatterns.set("direct", (percentPatterns.get("direct") || 0) + 1);
+                    }
+                }
+                // Check for Intl percent formatting
+                if (/style:\s*['"]percent/.test(line)) {
+                    percentPatterns.set("intl-percent", (percentPatterns.get("intl-percent") || 0) + 1);
+                }
+                // Check for inconsistent decimal places in percentages
+                if (/toFixed\((\d)\).*%|%.*toFixed\((\d)\)/.test(line)) {
+                    const match = line.match(/toFixed\((\d)\)/);
+                    if (match) {
+                        percentPatterns.set(`percent-${match[1]}dp`, (percentPatterns.get(`percent-${match[1]}dp`) || 0) + 1);
+                    }
+                }
+            }
+        }
+        // Check for mixed patterns
+        if (percentPatterns.has("multiply-100") && percentPatterns.has("direct")) {
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "mixed-percent-patterns",
+                severity: "warning",
+                message: "Mixed percentage patterns: some multiply by 100, some display directly",
+                suggestion: "Standardize: either store as 0-1 and multiply, or store as 0-100",
+            });
+        }
+        return {
+            name: "Percentage Display",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 5. Large Number Abbreviation
+     * Check for consistent K, M, B abbreviation patterns
+     */
+    async checkLargeNumberAbbreviation() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const abbreviationPatterns = new Map();
+        let hasCompactNotation = false;
+        for (const file of files) {
+            const content = fs.readFileSync(file, "utf8");
+            const lines = content.split("\n");
+            if (/notation:\s*['"]compact/.test(content)) {
+                hasCompactNotation = true;
+            }
+            for (let i = 0; i < lines.length; i++) {
+                const line = lines[i];
+                // Check for manual abbreviation functions
+                if (/formatNumber|abbreviate|compact|shorten/i.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 10, lines.length)).join("\n");
+                    // Check patterns used
+                    if (/['"]K['"]|\/\s*1000/.test(contextBlock)) {
+                        abbreviationPatterns.set("K", (abbreviationPatterns.get("K") || 0) + 1);
+                    }
+                    if (/['"]M['"]|\/\s*1000000/.test(contextBlock)) {
+                        abbreviationPatterns.set("M", (abbreviationPatterns.get("M") || 0) + 1);
+                    }
+                    if (/['"]k['"]/.test(contextBlock)) {
+                        abbreviationPatterns.set("k-lowercase", (abbreviationPatterns.get("k-lowercase") || 0) + 1);
+                    }
+                }
+                // Check for hardcoded abbreviation logic
+                if (/>\s*1000000|>\s*1000000|>=\s*1000000/.test(line)) {
+                    issues.push({
+                        file,
+                        line: i + 1,
+                        type: "hardcoded-abbreviation-threshold",
+                        severity: "info",
+                        message: "Hardcoded number abbreviation threshold",
+                        suggestion: "Use Intl.NumberFormat with notation: 'compact' for automatic abbreviation",
+                        snippet: line.trim().substring(0, 80),
+                    });
+                }
+            }
+        }
+        // Check for inconsistent casing
+        if (abbreviationPatterns.has("K") && abbreviationPatterns.has("k-lowercase")) {
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "inconsistent-abbreviation-case",
+                severity: "info",
+                message: "Mixed K/k casing in number abbreviations",
+                suggestion: "Standardize on uppercase K for thousands (1K, 1M, 1B)",
+            });
+        }
+        if (!hasCompactNotation && abbreviationPatterns.size > 0) {
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "manual-abbreviation",
+                severity: "info",
+                message: "Manual number abbreviation - consider using Intl compact notation",
+                suggestion: "Intl.NumberFormat with notation: 'compact' handles all cases automatically",
+            });
+        }
+        return {
+            name: "Large Number Abbreviation",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 6. Truncation Patterns
+     * Check for consistent text truncation handling
+     */
+    async checkTruncationPatterns() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const truncationPatterns = 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 CSS truncation
+                if (/truncate|text-ellipsis|line-clamp/.test(line)) {
+                    if (/truncate/.test(line)) {
+                        truncationPatterns.set("truncate", (truncationPatterns.get("truncate") || 0) + 1);
+                    }
+                    if (/line-clamp-(\d)/.test(line)) {
+                        const match = line.match(/line-clamp-(\d)/);
+                        if (match) {
+                            truncationPatterns.set(`line-clamp-${match[1]}`, (truncationPatterns.get(`line-clamp-${match[1]}`) || 0) + 1);
+                        }
+                    }
+                }
+                // Check for JS truncation
+                if (/\.substring\(|\.slice\(|\.substr\(/.test(line)) {
+                    const contextBlock = lines.slice(i, Math.min(i + 3, lines.length)).join("\n");
+                    // Check for ellipsis addition
+                    if (/\.\.\.|…|ellipsis/i.test(contextBlock)) {
+                        truncationPatterns.set("js-truncate", (truncationPatterns.get("js-truncate") || 0) + 1);
+                        // Check for proper ellipsis character
+                        if (/['"]\.\.\.['"]/.test(contextBlock) && !/['"]…['"]/.test(contextBlock)) {
+                            issues.push({
+                                file,
+                                line: i + 1,
+                                type: "three-dots-not-ellipsis",
+                                severity: "info",
+                                message: "Using '...' instead of proper ellipsis character '…'",
+                                suggestion: "Use the Unicode ellipsis character (…) or CSS text-overflow: ellipsis",
+                                snippet: line.trim().substring(0, 80),
+                            });
+                        }
+                    }
+                }
+                // Check for truncation without tooltip
+                if (/truncate|line-clamp|text-ellipsis/.test(line)) {
+                    const contextBlock = lines.slice(Math.max(0, i - 5), Math.min(i + 5, lines.length)).join("\n");
+                    const hasTooltip = /Tooltip|title=|aria-label/.test(contextBlock);
+                    if (!hasTooltip) {
+                        issues.push({
+                            file,
+                            line: i + 1,
+                            type: "truncate-no-tooltip",
+                            severity: "info",
+                            message: "Truncated text without tooltip to show full content",
+                            suggestion: "Add Tooltip or title attribute to show full text on hover",
+                            snippet: line.trim().substring(0, 80),
+                        });
+                    }
+                }
+            }
+        }
+        // Report truncation pattern usage
+        if (truncationPatterns.size > 3) {
+            const sorted = [...truncationPatterns.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "many-truncation-patterns",
+                severity: "info",
+                message: `${truncationPatterns.size} truncation patterns: ${sorted.slice(0, 4).map(([p, c]) => `${p}(${c})`).join(", ")}`,
+                suggestion: "Standardize on CSS truncation (truncate, line-clamp-2) over JS truncation",
+            });
+        }
+        return {
+            name: "Truncation Patterns",
+            passed: true,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 7. Empty/Null Placeholders
+     * Check for consistent empty data display
+     */
+    async checkEmptyNullPlaceholders() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const placeholderPatterns = 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 various empty placeholders
+                if (/\|\|\s*['"](-|—|N\/A|n\/a|None|none|Empty|empty|\?)['"]/.test(line)) {
+                    const match = line.match(/\|\|\s*['"](-|—|N\/A|n\/a|None|none|Empty|empty|\?)['"]/);
+                    if (match) {
+                        const placeholder = match[1];
+                        placeholderPatterns.set(placeholder, (placeholderPatterns.get(placeholder) || 0) + 1);
+                    }
+                }
+                // Check for ternary with empty placeholders
+                if (/\?\s*[^:]+\s*:\s*['"](-|—|N\/A|n\/a|None|none)['"]/i.test(line)) {
+                    const match = line.match(/:\s*['"](-|—|N\/A|n\/a|None|none)['"]/i);
+                    if (match) {
+                        placeholderPatterns.set(match[1], (placeholderPatterns.get(match[1]) || 0) + 1);
+                    }
+                }
+                // Check for ?? operator placeholders
+                if (/\?\?\s*['"](-|—|N\/A|n\/a|None|none)['"]/i.test(line)) {
+                    const match = line.match(/\?\?\s*['"](-|—|N\/A|n\/a|None|none)['"]/i);
+                    if (match) {
+                        placeholderPatterns.set(match[1], (placeholderPatterns.get(match[1]) || 0) + 1);
+                    }
+                }
+            }
+        }
+        // Check for inconsistent placeholders
+        if (placeholderPatterns.size > 2) {
+            const sorted = [...placeholderPatterns.entries()].sort((a, b) => b[1] - a[1]);
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "inconsistent-empty-placeholders",
+                severity: "warning",
+                message: `Multiple empty data placeholders: ${sorted.map(([p, c]) => `"${p}"(${c})`).join(", ")}`,
+                suggestion: "Standardize on one placeholder (recommended: '—' em dash or 'N/A')",
+            });
+        }
+        // Check for hyphen vs em-dash
+        if (placeholderPatterns.has("-") && !placeholderPatterns.has("—")) {
+            issues.push({
+                file: "codebase-wide",
+                line: 0,
+                type: "hyphen-not-emdash",
+                severity: "info",
+                message: "Using hyphen (-) instead of em dash (—) for empty placeholders",
+                suggestion: "Use em dash (—) for better visual distinction from data",
+            });
+        }
+        return {
+            name: "Empty/Null Placeholders",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * 8. Decimal Precision
+     * Check for consistent decimal place handling
+     */
+    async checkDecimalPrecision() {
+        const startTime = Date.now();
+        const issues = [];
+        const files = await this.getTsxFiles();
+        const precisionByContext = 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 toFixed usage
+                if (/\.toFixed\((\d)\)/.test(line)) {
+                    const match = line.match(/\.toFixed\((\d)\)/);
+                    if (match) {
+                        const precision = match[1];
+                        const contextBlock = lines.slice(Math.max(0, i - 5), Math.min(i + 5, lines.length)).join("\n");
+                        // Determine context
+                        let context = "general";
+                        if (/price|cost|amount|total|fee|dollar|currency/i.test(contextBlock)) {
+                            context = "currency";
+                        }
+                        else if (/percent|rate|ratio/i.test(contextBlock)) {
+                            context = "percentage";
+                        }
+                        else if (/weight|dimension|size|measure/i.test(contextBlock)) {
+                            context = "measurement";
+                        }
+                        if (!precisionByContext.has(context)) {
+                            precisionByContext.set(context, new Map());
+                        }
+                        const contextMap = precisionByContext.get(context);
+                        contextMap.set(precision, (contextMap.get(precision) || 0) + 1);
+                    }
+                }
+            }
+        }
+        // Check for inconsistency within each context
+        for (const [context, precisions] of precisionByContext.entries()) {
+            if (precisions.size > 1) {
+                const sorted = [...precisions.entries()].sort((a, b) => b[1] - a[1]);
+                issues.push({
+                    file: "codebase-wide",
+                    line: 0,
+                    type: `inconsistent-${context}-precision`,
+                    severity: context === "currency" ? "warning" : "info",
+                    message: `Inconsistent decimal precision for ${context}: ${sorted.map(([p, c]) => `${p}dp(${c})`).join(", ")}`,
+                    suggestion: context === "currency" ? "Currency should consistently use 2 decimal places" : `Standardize ${context} precision`,
+                });
+            }
+        }
+        return {
+            name: "Decimal Precision",
+            passed: issues.filter((i) => i.severity === "error").length === 0,
+            blocking: false,
+            issues,
+            duration: Date.now() - startTime,
+        };
+    }
+    /**
+     * Run all checks
+     */
+    async runAll(filter) {
+        const startTime = Date.now();
+        const checks = [];
+        const checkMap = {
+            numbers: () => this.checkNumberFormatting(),
+            currency: () => this.checkCurrencyDisplay(),
+            datetime: () => this.checkDateTimeFormatting(),
+            percent: () => this.checkPercentageDisplay(),
+            abbreviation: () => this.checkLargeNumberAbbreviation(),
+            truncation: () => this.checkTruncationPatterns(),
+            placeholder: () => this.checkEmptyNullPlaceholders(),
+            precision: () => this.checkDecimalPrecision(),
+        };
+        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 Data Display",
+            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.UIDataDisplayModule = UIDataDisplayModule;
+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 UIDataDisplayModule({ verbose });
+    const result = await module.runAll(filter);
+    console.log((0, console_chars_1.createDivider)(80, "heavy"));
+    console.log(`${console_chars_1.emoji.chart} UI DATA DISPLAY 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-data-display.js.map