@empline/preflight 1.0.20

package/dist/checks/architecture/shared-component-enforcement.js

@@ -0,0 +1,725 @@
+#!/usr/bin/env tsx
+"use strict";
+/**
+ * Shared Component Enforcement Preflight
+ *
+ * Enforces usage of shared/unified components instead of custom implementations.
+ * This is critical for maintaining UI consistency like Shopify, Google, Facebook.
+ *
+ * Checks:
+ * 1. Empty states must use UnifiedEmptyState
+ * 2. Error states must use UnifiedErrorState
+ * 3. Loading states must use UnifiedSkeleton or LoadingState
+ * 4. Dialogs must use UnifiedDialog
+ * 5. Product cards must use UnifiedProductCard
+ * 6. Page headers must use UnifiedPageHeader
+ * 7. Breadcrumbs must use UnifiedBreadcrumbs
+ * 8. Price displays must use UnifiedPriceDisplay
+ * 9. Pagination must use UnifiedPagination
+ * 10. Search inputs must use UnifiedSearch or SearchInput
+ *
+ * Usage:
+ *   pnpm preflight:shared-component-enforcement
+ *   pnpm preflight:shared-component-enforcement empty     # Empty states only
+ *   pnpm preflight:shared-component-enforcement error     # Error states only
+ *   pnpm preflight:shared-component-enforcement loading   # Loading states only
+ *   pnpm preflight:shared-component-enforcement dialog    # Dialogs only
+ *   pnpm preflight:shared-component-enforcement all       # All checks
+ */
+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.tags = exports.description = exports.blocking = exports.category = exports.name = exports.id = void 0;
+const fs = __importStar(require("fs"));
+const glob_1 = require("glob");
+const console_chars_1 = require("../../utils/console-chars");
+const universal_progress_reporter_1 = require("../system/universal-progress-reporter");
+// Check metadata
+exports.id = "architecture/shared-component-enforcement";
+exports.name = "Shared Component Enforcement";
+exports.category = "architecture";
+exports.blocking = false;
+exports.description = "Shared Component Enforcement Preflight";
+exports.tags = ["architecture"];
+const EXCLUDED_PATTERNS = [
+    "**/node_modules/**",
+    "**/.next/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/*.test.tsx",
+    "**/*.spec.tsx",
+    "**/*.stories.tsx",
+    "tests/**",
+    "scripts/**",
+    // Exclude the shared component definitions themselves
+    "components/shared/**",
+    "components/ui/**",
+    // Exclude the base UI component library (these ARE the primitives)
+    "packages/ui/**",
+];
+async function getAllTsxFiles() {
+    return (0, glob_1.glob)("**/*.tsx", { ignore: EXCLUDED_PATTERNS });
+}
+/**
+ * Check 1: Empty State Enforcement
+ * All empty states should use UnifiedEmptyState
+ */
+async function checkEmptyStateEnforcement() {
+    const issues = [];
+    const files = await getAllTsxFiles();
+    // Files that are excluded from empty state checks (they have specific designs)
+    const EXCLUDED_FILES = [
+        "loading.tsx", // Loading skeletons are not empty states
+        "LogSettingsDropdown.tsx", // Inline dropdown text
+        "ListingTableRow.tsx", // Table cell text
+        "ImagesTable.tsx", // Table cell text
+        "UnifiedHeader.tsx", // This IS a shared component
+        "AuthPageLayout.tsx", // Auth layout with icons is intentional design
+        "HeroSearchBar.tsx", // Hero section design
+        "HeroSection.tsx", // Hero section design
+        "LoginPageClient.tsx", // Auth page design
+        "RegisterPageClient.tsx", // Auth page design
+        "LoginPerksSection.tsx", // Auth perks section
+        "LoginFormSection.tsx", // Auth form section
+        "ContactMethodCard.tsx", // Contact card design
+        "PricingTierCard.tsx", // Pricing card design
+        "FeeComparisonTable.tsx", // Pricing table design
+        "MegaMenuButton.tsx", // Navigation component
+        "ProgressTracker.tsx", // Upload progress UI
+        "UploadProgressStepper.tsx", // Upload stepper UI
+        "SlotCard.tsx", // Upload slot card
+        "StorePlansDisplay.tsx", // Store plans display
+        "CSVImportPanel.tsx", // CSV import UI
+        "ProductReviews.tsx", // Reviews section
+        "ProductActionBar.tsx", // Product action bar
+        "SearchOverlay.tsx", // Search overlay
+        "CartDrawer.tsx", // Cart drawer
+        // Page-level components with specific designs
+        "SearchPageClient.tsx", // Search page has specific design
+        "CommunityCollectionsClient.tsx", // Collections page design
+        "ChangelogClient.tsx", // Changelog page design
+        "BlogPageClient.tsx", // Blog page design
+        "AboutPageClient.tsx", // About page design
+        "StoreDailySummaryClient.tsx", // Dashboard design
+        "DashboardPageClient.tsx", // Dashboard design
+        "SmartProductNotFoundContent.tsx", // 404 page design
+        "page.tsx", // Generic page files have specific designs
+        "AdminAnalyticsClient.tsx", // Admin analytics design
+        "ProfileClient.tsx", // Profile page design
+        "AccountBillingClient.tsx", // Billing page design
+    ];
+    // Patterns that indicate custom empty states
+    const EMPTY_STATE_PATTERNS = [
+        { pattern: /No\s+\w+\s+(found|available|yet)/i, name: "No X found/available" },
+        { pattern: /Your\s+\w+\s+is\s+empty/i, name: "Your X is empty" },
+        { pattern: /There\s+are\s+no\s+\w+/i, name: "There are no X" },
+        { pattern: /Nothing\s+to\s+(show|display)/i, name: "Nothing to show" },
+        { pattern: /No\s+results/i, name: "No results" },
+        // More specific pattern - "Empty state" or "Empty list" but not "Empty rows" (form label)
+        { pattern: /Empty\s+(state|list|collection|cart|inbox)/i, name: "Empty X" },
+    ];
+    for (const file of files) {
+        // Skip excluded files
+        const normalizedFile = file.replace(/\\/g, "/");
+        if (EXCLUDED_FILES.some((excluded) => normalizedFile.endsWith(excluded)))
+            continue;
+        const content = fs.readFileSync(file, "utf8");
+        const lines = content.split("\n");
+        // Skip if already using UnifiedEmptyState or UnifiedStatus (which handles empty states)
+        if (content.includes("UnifiedEmptyState") || content.includes("UnifiedStatus"))
+            continue;
+        // Check for empty state patterns
+        for (const { pattern, name } of EMPTY_STATE_PATTERNS) {
+            const match = content.match(pattern);
+            if (match) {
+                // Find the line number
+                const matchIndex = content.indexOf(match[0]);
+                const lineNum = content.substring(0, matchIndex).split("\n").length;
+                const line = lines[lineNum - 1] || "";
+                // Skip if it's in a comment or string constant definition
+                if (line.trim().startsWith("//") || line.trim().startsWith("*"))
+                    continue;
+                if (/const\s+\w+\s*=\s*["']/.test(line))
+                    continue;
+                // Skip toast messages (not UI components)
+                if (/toast\.(error|success|warning|info)\s*\(/.test(line))
+                    continue;
+                // Skip if preflight-ignore comment is nearby (within 15 lines before)
+                const contextLines = lines.slice(Math.max(0, lineNum - 15), lineNum);
+                if (contextLines.some((l) => l.includes("preflight-ignore")))
+                    continue;
+                // Skip table cell empty text (inline text in tables)
+                if (/<TableCell[^>]*>/.test(line) || /<TableCell/.test(lines[lineNum - 2] || ""))
+                    continue;
+                // Skip inline Typography with "No X" that's just informational text
+                if (/<Typography[^>]*variant=["']caption["']/.test(line))
+                    continue;
+                if (/<Typography[^>]*variant=["']body2["']/.test(line) &&
+                    /color=["']text\.secondary["']/.test(line))
+                    continue;
+                // Check if it's rendered in JSX (not just a variable)
+                const surroundingContext = lines
+                    .slice(Math.max(0, lineNum - 3), Math.min(lines.length, lineNum + 3))
+                    .join("\n");
+                if (/<\w+/.test(surroundingContext) && />\s*{?/.test(surroundingContext)) {
+                    issues.push({
+                        file,
+                        line: lineNum,
+                        severity: "warning",
+                        rule: "use-unified-empty-state",
+                        message: `Custom empty state pattern "${name}" - use UnifiedEmptyState`,
+                        suggestion: 'Import { UnifiedEmptyState } from "@/components/shared" with appropriate variant',
+                        snippet: match[0],
+                    });
+                    break; // Only report once per file
+                }
+            }
+        }
+        // Check for centered icon + text pattern (common custom empty state)
+        if (/className=["'][^"']*text-center[^"']*["']/.test(content) &&
+            (content.includes("lucide-react") || content.includes("@mui/icons"))) {
+            const hasEmptyIndicator = /size=\{?\d+\}?/.test(content) &&
+                (/text-muted|text-gray|opacity-/.test(content) || /color.*secondary/i.test(content));
+            if (hasEmptyIndicator && !content.includes("UnifiedEmptyState")) {
+                issues.push({
+                    file,
+                    severity: "info",
+                    rule: "centered-icon-empty-state",
+                    message: "Centered icon + text pattern detected - consider UnifiedEmptyState",
+                    suggestion: "UnifiedEmptyState provides consistent styling and animations",
+                });
+            }
+        }
+    }
+    return {
+        name: "Empty State Enforcement",
+        issues,
+        passed: issues.filter((i) => i.severity === "error").length === 0,
+    };
+}
+/**
+ * Check 2: Error State Enforcement
+ * All error states should use UnifiedErrorState
+ */
+async function checkErrorStateEnforcement() {
+    const issues = [];
+    const files = await getAllTsxFiles();
+    // Files that are excluded from error state checks (they have specific designs)
+    const EXCLUDED_FILES = [
+        "app/auth/error/", // Auth error pages use AuthPageLayout pattern
+        "app/error.tsx", // Root error boundary uses UnifiedErrorState
+        "app/admin/error.tsx", // Admin error uses UnifiedErrorState
+        "components/shared/UnifiedErrorState.tsx", // The component itself
+        "components/shared/UnifiedEmptyState.tsx", // Has error variant
+    ];
+    const ERROR_PATTERNS = [
+        { pattern: /Something\s+went\s+wrong/i, name: "Something went wrong" },
+        { pattern: /An\s+error\s+occurred/i, name: "An error occurred" },
+        { pattern: /Failed\s+to\s+load/i, name: "Failed to load" },
+        { pattern: /Unable\s+to\s+\w+/i, name: "Unable to X" },
+        { pattern: /Error\s+loading/i, name: "Error loading" },
+        { pattern: /Oops/i, name: "Oops" },
+    ];
+    for (const file of files) {
+        // Skip excluded files
+        const normalizedFile = file.replace(/\\/g, "/");
+        if (EXCLUDED_FILES.some((excluded) => normalizedFile.includes(excluded)))
+            continue;
+        const content = fs.readFileSync(file, "utf8");
+        const lines = content.split("\n");
+        // Skip if using UnifiedErrorState or UnifiedEmptyState with error variant
+        if (content.includes("UnifiedErrorState"))
+            continue;
+        if (content.includes("UnifiedEmptyState") && /variant=["']error["']/.test(content))
+            continue;
+        for (const { pattern, name } of ERROR_PATTERNS) {
+            const match = content.match(pattern);
+            if (match) {
+                const matchIndex = content.indexOf(match[0]);
+                const lineNum = content.substring(0, matchIndex).split("\n").length;
+                const line = lines[lineNum - 1] || "";
+                if (line.trim().startsWith("//") || line.trim().startsWith("*"))
+                    continue;
+                // Check if it's in JSX context
+                const surroundingContext = lines
+                    .slice(Math.max(0, lineNum - 3), Math.min(lines.length, lineNum + 3))
+                    .join("\n");
+                if (/<\w+/.test(surroundingContext)) {
+                    issues.push({
+                        file,
+                        line: lineNum,
+                        severity: "warning",
+                        rule: "use-unified-error-state",
+                        message: `Custom error state "${name}" - use UnifiedErrorState`,
+                        suggestion: 'Import { UnifiedErrorState } from "@/components/shared" for consistent error UX',
+                        snippet: match[0],
+                    });
+                    break;
+                }
+            }
+        }
+    }
+    return {
+        name: "Error State Enforcement",
+        issues,
+        passed: issues.filter((i) => i.severity === "error").length === 0,
+    };
+}
+/**
+ * Check 3: Loading State Enforcement
+ * All loading states should use UnifiedSkeleton or LoadingState
+ */
+async function checkLoadingStateEnforcement() {
+    const issues = [];
+    const files = await getAllTsxFiles();
+    // Files that are excluded (they have specific loading designs)
+    const EXCLUDED_LOADING_FILES = [
+        "SlotCard.tsx", // Upload slot card has specific design
+        "CompactListingRow.tsx", // Compact row has inline spinner
+        "ShippingCalculator.tsx", // Shipping calc has inline spinner
+        "ProductSelectionStep.tsx", // Step has inline spinner
+        "SlabScannerDialog.tsx", // Scanner dialog has specific design
+    ];
+    for (const file of files) {
+        // Skip excluded files
+        const normalizedFile = file.replace(/\\/g, "/");
+        if (EXCLUDED_LOADING_FILES.some((excluded) => normalizedFile.endsWith(excluded)))
+            continue;
+        const content = fs.readFileSync(file, "utf8");
+        const lines = content.split("\n");
+        // Skip if using unified loading components
+        if (content.includes("UnifiedSkeleton") ||
+            content.includes("LoadingState") ||
+            content.includes("SuspenseFallback")) {
+            continue;
+        }
+        // Check for custom skeleton implementations
+        if (content.includes("Skeleton") && !content.includes("@/components/shared")) {
+            // Check if importing from MUI or other external sources (not local components)
+            const skeletonImport = content.match(/import.*Skeleton.*from\s+["']([^"']+)["']/);
+            if (skeletonImport) {
+                const importPath = skeletonImport[1];
+                // Skip local component imports (they may wrap UnifiedSkeleton)
+                if (importPath.startsWith("./") || importPath.startsWith("../"))
+                    continue;
+                // Skip if importing from our components
+                if (importPath.includes("@/components"))
+                    continue;
+                const lineNum = content.indexOf(skeletonImport[0]);
+                issues.push({
+                    file,
+                    line: content.substring(0, lineNum).split("\n").length,
+                    severity: "warning",
+                    rule: "use-unified-skeleton",
+                    message: `Importing Skeleton from "${importPath}" - use UnifiedSkeleton`,
+                    suggestion: 'Import { UnifiedSkeleton } from "@/components/shared" for consistent loading states',
+                });
+            }
+        }
+        // Check for custom loading spinners
+        if (content.includes("CircularProgress") && !content.includes("LoadingState")) {
+            const match = content.match(/CircularProgress/);
+            if (match) {
+                const matchIndex = content.indexOf(match[0]);
+                const lineNum = content.substring(0, matchIndex).split("\n").length;
+                issues.push({
+                    file,
+                    line: lineNum,
+                    severity: "info",
+                    rule: "use-loading-state",
+                    message: "CircularProgress detected - consider LoadingState for consistency",
+                    suggestion: 'Import { LoadingState } from "@/components/shared" for consistent loading UX',
+                });
+            }
+        }
+        // Check for "Loading..." text without proper component
+        const loadingTextMatch = content.match(/>\s*Loading\.{3}\s*</);
+        if (loadingTextMatch) {
+            const matchIndex = content.indexOf(loadingTextMatch[0]);
+            const lineNum = content.substring(0, matchIndex).split("\n").length;
+            issues.push({
+                file,
+                line: lineNum,
+                severity: "info",
+                rule: "loading-text-pattern",
+                message: '"Loading..." text - use LoadingState or UnifiedSkeleton',
+                suggestion: "Shared loading components provide consistent styling and accessibility",
+            });
+        }
+    }
+    return {
+        name: "Loading State Enforcement",
+        issues,
+        passed: issues.filter((i) => i.severity === "error").length === 0,
+    };
+}
+/**
+ * Check 4: Dialog Enforcement
+ * All dialogs should use UnifiedDialog
+ */
+async function checkDialogEnforcement() {
+    const issues = [];
+    const files = await getAllTsxFiles();
+    // Files that are excluded (they have specific designs)
+    const EXCLUDED_DIALOG_FILES = [
+        "NavigationSidebar.tsx", // Navigation sidebar has specific design
+        "SearchOverlay.tsx", // Search overlay has specific design
+    ];
+    for (const file of files) {
+        // Skip excluded files
+        const normalizedFile = file.replace(/\\/g, "/");
+        if (EXCLUDED_DIALOG_FILES.some((excluded) => normalizedFile.endsWith(excluded)))
+            continue;
+        const content = fs.readFileSync(file, "utf8");
+        // Skip if using UnifiedDialog
+        if (content.includes("UnifiedDialog"))
+            continue;
+        // Check for MUI Dialog imports
+        const dialogImport = content.match(/import.*Dialog.*from\s+["']@mui\/material["']/);
+        if (dialogImport) {
+            const lineNum = content.indexOf(dialogImport[0]);
+            issues.push({
+                file,
+                line: content.substring(0, lineNum).split("\n").length,
+                severity: "warning",
+                rule: "use-unified-dialog",
+                message: "MUI Dialog import - use UnifiedDialog for consistency",
+                suggestion: 'Import { UnifiedDialog } from "@/components/shared" for consistent dialog styling',
+            });
+        }
+        // Check for custom modal implementations
+        if (content.includes("modal") &&
+            content.includes("fixed") &&
+            content.includes("inset-0") &&
+            !content.includes("UnifiedDialog")) {
+            issues.push({
+                file,
+                severity: "info",
+                rule: "custom-modal-pattern",
+                message: "Custom modal pattern detected - consider UnifiedDialog",
+                suggestion: "UnifiedDialog provides consistent styling, animations, and accessibility",
+            });
+        }
+    }
+    return {
+        name: "Dialog Enforcement",
+        issues,
+        passed: issues.filter((i) => i.severity === "error").length === 0,
+    };
+}
+/**
+ * Check 5: Page Header Enforcement
+ * All page headers should use UnifiedPageHeader
+ */
+async function checkPageHeaderEnforcement() {
+    const issues = [];
+    const files = await getAllTsxFiles();
+    // Files that are excluded (they ARE shared components or have specific designs)
+    const EXCLUDED_HEADER_FILES = [
+        "UnifiedHeader.tsx", // This IS the unified header component
+        "UnifiedPageHeader.tsx", // This IS the page header component
+        "HeroSection.tsx", // Hero sections have specific designs
+        "HeroSearchBar.tsx", // Hero search has specific design
+    ];
+    for (const file of files) {
+        // Skip excluded files
+        const normalizedFile = file.replace(/\\/g, "/");
+        if (EXCLUDED_HEADER_FILES.some((excluded) => normalizedFile.endsWith(excluded)))
+            continue;
+        const content = fs.readFileSync(file, "utf8");
+        const lines = content.split("\n");
+        // Skip if using UnifiedPageHeader or UnifiedHeader
+        if (content.includes("UnifiedPageHeader") || content.includes("UnifiedHeader"))
+            continue;
+        // Check for custom page header patterns
+        // Pattern: h1/h2 + description + actions in a flex container
+        const hasHeading = /<h[12][^>]*>/.test(content) || /variant=["']h[12]["']/.test(content);
+        const hasFlexHeader = /className=["'][^"']*flex[^"']*justify-between[^"']*["']/.test(content) ||
+            /className=["'][^"']*flex[^"']*items-center[^"']*["']/.test(content);
+        const hasActions = content.includes("Button") &&
+            (content.includes("Add") || content.includes("Create") || content.includes("New"));
+        if (hasHeading && hasFlexHeader && hasActions) {
+            // Find the heading line
+            let lineNum = 1;
+            for (let i = 0; i < lines.length; i++) {
+                if (/<h[12]/.test(lines[i]) || /variant=["']h[12]/.test(lines[i])) {
+                    lineNum = i + 1;
+                    break;
+                }
+            }
+            issues.push({
+                file,
+                line: lineNum,
+                severity: "info",
+                rule: "use-unified-page-header",
+                message: "Custom page header pattern - consider UnifiedPageHeader",
+                suggestion: 'Import { UnifiedPageHeader } from "@/components/shared" for consistent page headers',
+            });
+        }
+    }
+    return {
+        name: "Page Header Enforcement",
+        issues,
+        passed: issues.filter((i) => i.severity === "error").length === 0,
+    };
+}
+/**
+ * Check 6: Breadcrumbs Enforcement
+ */
+async function checkBreadcrumbsEnforcement() {
+    const issues = [];
+    const files = await getAllTsxFiles();
+    for (const file of files) {
+        const content = fs.readFileSync(file, "utf8");
+        // Skip if using UnifiedBreadcrumbs
+        if (content.includes("UnifiedBreadcrumbs"))
+            continue;
+        // Check for MUI Breadcrumbs
+        const breadcrumbsImport = content.match(/import.*Breadcrumbs.*from\s+["']@mui\/material["']/);
+        if (breadcrumbsImport) {
+            const lineNum = content.indexOf(breadcrumbsImport[0]);
+            issues.push({
+                file,
+                line: content.substring(0, lineNum).split("\n").length,
+                severity: "warning",
+                rule: "use-unified-breadcrumbs",
+                message: "MUI Breadcrumbs import - use UnifiedBreadcrumbs",
+                suggestion: 'Import { UnifiedBreadcrumbs } from "@/components/shared" for consistent breadcrumbs',
+            });
+        }
+        // Check for custom breadcrumb patterns
+        if (content.includes("breadcrumb") &&
+            content.includes("/") &&
+            !content.includes("UnifiedBreadcrumbs")) {
+            if (/<nav[^>]*aria-label=["']breadcrumb["']/.test(content)) {
+                issues.push({
+                    file,
+                    severity: "info",
+                    rule: "custom-breadcrumbs",
+                    message: "Custom breadcrumbs implementation - use UnifiedBreadcrumbs",
+                    suggestion: "UnifiedBreadcrumbs provides consistent styling and SEO schema",
+                });
+            }
+        }
+    }
+    return {
+        name: "Breadcrumbs Enforcement",
+        issues,
+        passed: issues.filter((i) => i.severity === "error").length === 0,
+    };
+}
+/**
+ * Check 7: Price Display Enforcement
+ * Only flag inline price formatting - formatCurrency is the correct utility
+ * toLocaleString() for counts/numbers is fine, only flag price-specific patterns
+ */
+async function checkPriceDisplayEnforcement() {
+    const issues = [];
+    const files = await getAllTsxFiles();
+    // Files that are excluded (they use price ranges or have specific designs)
+    const EXCLUDED_PRICE_FILES = [
+        "Filter", // Filter components use price ranges
+        "CardPrice.tsx", // Card price component IS the price display
+        "AutoSaveIndicator.tsx", // Auto-save indicator
+        "ShippingBreakdown.tsx", // Shipping breakdown
+        "RelatedItems.tsx", // Related items
+        "FeaturedListingCard.tsx", // Featured card
+        "CardRecognitionCard.tsx", // Recognition card
+        "WhatnotSettingsContent.tsx", // Integration settings
+        // Page files that use toLocaleString for counts (not prices)
+        "trading-card-games/page.tsx",
+        "sports-cards/page.tsx",
+        "CollectorsPageClient.tsx",
+        "CommunityCollectionsClient.tsx",
+        "PublicProfileClient.tsx",
+        "recognition-result/index.tsx",
+        "[category]/page.tsx",
+        "[slug]/page.tsx",
+    ];
+    for (const file of files) {
+        // Skip excluded files
+        const normalizedFile = file.replace(/\\/g, "/");
+        if (EXCLUDED_PRICE_FILES.some((excluded) => normalizedFile.includes(excluded)))
+            continue;
+        const content = fs.readFileSync(file, "utf8");
+        const lines = content.split("\n");
+        // Skip if using UnifiedPriceDisplay or formatCurrency (both are correct)
+        if (content.includes("UnifiedPriceDisplay") || content.includes("formatCurrency"))
+            continue;
+        // Only check for truly inline price formatting with dollar signs
+        // Pattern: `$${something.toFixed(2)}` or similar
+        const pricePatterns = [
+            /\$\$\{[^}]*\.toFixed\(2\)\}/, // `$${price.toFixed(2)}`
+        ];
+        for (const pattern of pricePatterns) {
+            const match = content.match(pattern);
+            if (match) {
+                const matchIndex = content.indexOf(match[0]);
+                const lineNum = content.substring(0, matchIndex).split("\n").length;
+                issues.push({
+                    file,
+                    line: lineNum,
+                    severity: "info",
+                    rule: "use-unified-price-display",
+                    message: "Inline price formatting - use formatCurrency or UnifiedPriceDisplay",
+                    suggestion: "Use formatCurrency from @/lib/utils/format for consistent currency formatting",
+                });
+                break;
+            }
+        }
+    }
+    return {
+        name: "Price Display Enforcement",
+        issues,
+        passed: issues.filter((i) => i.severity === "error").length === 0,
+    };
+}
+/**
+ * Check 8: Pagination Enforcement
+ */
+async function checkPaginationEnforcement() {
+    const issues = [];
+    const files = await getAllTsxFiles();
+    for (const file of files) {
+        const content = fs.readFileSync(file, "utf8");
+        // Skip if using UnifiedPagination
+        if (content.includes("UnifiedPagination"))
+            continue;
+        // Check for MUI Pagination
+        const paginationImport = content.match(/import.*Pagination.*from\s+["']@mui\/material["']/);
+        if (paginationImport) {
+            const lineNum = content.indexOf(paginationImport[0]);
+            issues.push({
+                file,
+                line: content.substring(0, lineNum).split("\n").length,
+                severity: "warning",
+                rule: "use-unified-pagination",
+                message: "MUI Pagination import - use UnifiedPagination",
+                suggestion: 'Import { UnifiedPagination } from "@/components/shared" for consistent pagination',
+            });
+        }
+    }
+    return {
+        name: "Pagination Enforcement",
+        issues,
+        passed: issues.filter((i) => i.severity === "error").length === 0,
+    };
+}
+async function runChecks(mode) {
+    const reporter = (0, universal_progress_reporter_1.createUniversalProgressReporter)("Shared Component Enforcement");
+    console.log(`\n${console_chars_1.emoji.components} Shared Component Enforcement Preflight`);
+    console.log((0, console_chars_1.createDivider)(60, "heavy"));
+    const allChecks = {
+        empty: checkEmptyStateEnforcement,
+        error: checkErrorStateEnforcement,
+        loading: checkLoadingStateEnforcement,
+        dialog: checkDialogEnforcement,
+        header: checkPageHeaderEnforcement,
+        breadcrumbs: checkBreadcrumbsEnforcement,
+        price: checkPriceDisplayEnforcement,
+        pagination: checkPaginationEnforcement,
+    };
+    const checksToRun = mode && mode !== "all" && allChecks[mode] ? { [mode]: allChecks[mode] } : allChecks;
+    let totalIssues = 0;
+    let hasErrors = false;
+    const allIssues = [];
+    for (const [key, check] of Object.entries(checksToRun)) {
+        const result = await check();
+        allIssues.push(...result.issues);
+        const errorCount = result.issues.filter((i) => i.severity === "error").length;
+        const warnCount = result.issues.filter((i) => i.severity === "warning").length;
+        const infoCount = result.issues.filter((i) => i.severity === "info").length;
+        const icon = errorCount > 0
+            ? console_chars_1.emoji.error
+            : warnCount > 0
+                ? console_chars_1.emoji.warning
+                : infoCount > 0
+                    ? console_chars_1.emoji.info
+                    : console_chars_1.emoji.success;
+        console.log(`\n${icon} ${result.name}`);
+        console.log("-".repeat(40));
+        if (result.issues.length === 0) {
+            console.log("  No issues found");
+        }
+        else {
+            // Show all issues if --verbose flag is passed
+            const showAll = process.argv.includes("--verbose") || process.argv.includes("-v");
+            const issuesToShow = showAll ? result.issues : result.issues.slice(0, 5);
+            for (const issue of issuesToShow) {
+                const prefix = issue.severity === "error"
+                    ? console_chars_1.emoji.error
+                    : issue.severity === "warning"
+                        ? console_chars_1.emoji.warning
+                        : console_chars_1.emoji.info;
+                const location = issue.line ? `${issue.file}:${issue.line}` : issue.file;
+                console.log(`  ${prefix} ${location}`);
+                console.log(`     ${issue.message}`);
+            }
+            if (!showAll && result.issues.length > 5) {
+                console.log(`  ... and ${result.issues.length - 5} more issues`);
+            }
+        }
+        totalIssues += result.issues.length;
+        if (!result.passed)
+            hasErrors = true;
+    }
+    console.log("\n" + (0, console_chars_1.createDivider)(60, "heavy"));
+    console.log(`${console_chars_1.emoji.chart} Summary: ${totalIssues} issues found`);
+    // Show shared component reference
+    console.log(`\n${console_chars_1.emoji.hint} Shared Components Reference:`);
+    console.log("  • UnifiedEmptyState - Empty states (no results, no items)");
+    console.log("  • UnifiedErrorState - Error states (failed to load, etc.)");
+    console.log("  • UnifiedSkeleton / LoadingState - Loading states");
+    console.log("  • UnifiedDialog - Modal dialogs");
+    console.log("  • UnifiedPageHeader - Page headers with title + actions");
+    console.log("  • UnifiedBreadcrumbs - Navigation breadcrumbs");
+    console.log("  • UnifiedPriceDisplay - Currency/price formatting");
+    console.log("  • UnifiedPagination - Pagination controls");
+    console.log('  • All available from "@/components/shared"');
+    if (hasErrors) {
+        console.log(`\n${console_chars_1.emoji.error} Shared component enforcement FAILED`);
+        process.exit(1);
+    }
+    else if (totalIssues > 0) {
+        console.log(`\n${console_chars_1.emoji.warning} Shared component enforcement passed with warnings`);
+        process.exit(0);
+    }
+    else {
+        console.log(`\n${console_chars_1.emoji.success} Shared component enforcement PASSED`);
+        process.exit(0);
+    }
+}
+const mode = process.argv[2];
+runChecks(mode).catch(console.error);
+//# sourceMappingURL=shared-component-enforcement.js.map