@revealui/core 0.2.1 → 0.5.0

package/dist/optimization/build-optimizer.js

@@ -1,271 +0,0 @@
-/**
- * Build Performance Optimization
- *
- * Utilities for optimizing build performance and configuration
- */
-export const DEFAULT_NEXT_CONFIG = {
-    compiler: {
-        removeConsole: {
-            exclude: ['error', 'warn'],
-        },
-    },
-    swcMinify: true,
-    outputFileTracing: true,
-    experimental: {
-        optimizeCss: true,
-        optimizePackageImports: ['lodash', 'date-fns', 'recharts', '@radix-ui/react-icons'],
-    },
-    productionBrowserSourceMaps: false,
-    generateEtags: true,
-    poweredByHeader: false,
-    compress: true,
-};
-export const DEFAULT_WEBPACK_CONFIG = {
-    minimize: true,
-    splitChunks: {
-        chunks: 'all',
-        minSize: 20000,
-        maxSize: 244000,
-        minChunks: 1,
-        maxAsyncRequests: 30,
-        maxInitialRequests: 30,
-        cacheGroups: {
-            defaultVendors: {
-                test: /[\\/]node_modules[\\/]/,
-                priority: -10,
-                reuseExistingChunk: true,
-            },
-            default: {
-                minChunks: 2,
-                priority: -20,
-                reuseExistingChunk: true,
-            },
-        },
-    },
-    runtimeChunk: 'single',
-    moduleIds: 'deterministic',
-    chunkIds: 'deterministic',
-    concatenateModules: true,
-    usedExports: true,
-    sideEffects: true,
-    providedExports: true,
-    innerGraph: true,
-};
-export const DEFAULT_TURBOPACK_CONFIG = {
-    resolveExtensions: ['.tsx', '.ts', '.jsx', '.js', '.json'],
-    resolveAlias: {
-        '@': './src',
-        '@components': './src/components',
-        '@lib': './src/lib',
-        '@utils': './src/utils',
-    },
-};
-export const DEFAULT_CACHE_CONFIG = {
-    type: 'filesystem',
-    cacheDirectory: '.next/cache',
-    compression: 'gzip',
-    maxAge: 1000 * 60 * 60 * 24 * 7, // 1 week
-};
-export const DEFAULT_TREE_SHAKING_CONFIG = {
-    usedExports: true,
-    sideEffects: true,
-    providedExports: true,
-    innerGraph: true,
-    mangleExports: true,
-};
-/**
- * Generate package.json sideEffects field
- */
-export function generateSideEffectsConfig(includeCSS = true) {
-    if (!includeCSS) {
-        return false;
-    }
-    return ['*.css', '*.scss', '*.sass', '*.less'];
-}
-export const DEFAULT_MODULE_RESOLUTION = {
-    extensions: ['.tsx', '.ts', '.jsx', '.js', '.json'],
-    alias: {
-        '@': './src',
-        '@components': './src/components',
-        '@lib': './src/lib',
-        '@utils': './src/utils',
-        '@hooks': './src/hooks',
-        '@types': './src/types',
-    },
-    modules: ['node_modules'],
-    symlinks: true,
-    fullySpecified: false,
-};
-export const DEFAULT_PARALLEL_CONFIG = {
-    parallel: true,
-    cache: true,
-    threads: 4,
-};
-export const DEFAULT_PERFORMANCE_CONFIG = {
-    hints: 'warning',
-    maxEntrypointSize: 250000, // 250KB
-    maxAssetSize: 250000,
-    assetFilter: (assetFilename) => {
-        return !assetFilename.endsWith('.map');
-    },
-};
-/**
- * Analyze build performance
- */
-export function analyzeBuildPerformance(stats) {
-    const issues = [];
-    let score = 100;
-    // Check build duration
-    if (stats.duration > 60000) {
-        issues.push({
-            type: 'warning',
-            message: `Build time (${(stats.duration / 1000).toFixed(1)}s) is slow. Consider parallel builds.`,
-        });
-        score -= 10;
-    }
-    // Check output size
-    if (stats.outputSize > 1024 * 1024) {
-        issues.push({
-            type: 'warning',
-            message: `Output size (${(stats.outputSize / 1024 / 1024).toFixed(1)}MB) is large. Consider code splitting.`,
-        });
-        score -= 15;
-    }
-    // Check for large assets
-    const largeAssets = stats.assets.filter((a) => a.size > 250000);
-    if (largeAssets.length > 0) {
-        issues.push({
-            type: 'warning',
-            message: `${largeAssets.length} assets exceed 250KB. Consider optimization.`,
-        });
-        score -= 10;
-    }
-    // Check for errors
-    if (stats.errors.length > 0) {
-        issues.push({
-            type: 'error',
-            message: `${stats.errors.length} build errors found.`,
-        });
-        score -= 30;
-    }
-    // Check for warnings
-    if (stats.warnings.length > 5) {
-        issues.push({
-            type: 'warning',
-            message: `${stats.warnings.length} build warnings found.`,
-        });
-        score -= 5;
-    }
-    return {
-        score: Math.max(0, score),
-        issues,
-    };
-}
-/**
- * Generate tsconfig for optimal builds
- */
-export function generateOptimizedTSConfig() {
-    return {
-        compilerOptions: {
-            target: 'ES2020',
-            lib: ['ES2020', 'DOM', 'DOM.Iterable'],
-            module: 'ESNext',
-            moduleResolution: 'bundler',
-            resolveJsonModule: true,
-            isolatedModules: true,
-            jsx: 'preserve',
-            incremental: true,
-            strict: true,
-            esModuleInterop: true,
-            skipLibCheck: true,
-            forceConsistentCasingInFileNames: true,
-            noEmit: true,
-            paths: {
-                '@/*': ['./src/*'],
-                '@components/*': ['./src/components/*'],
-                '@lib/*': ['./src/lib/*'],
-                '@utils/*': ['./src/utils/*'],
-            },
-        },
-    };
-}
-export function shouldPrebuildDependency(packageName, config = {}) {
-    const { include = [], exclude = [] } = config;
-    if (exclude.includes(packageName)) {
-        return false;
-    }
-    if (include.length > 0) {
-        return include.includes(packageName);
-    }
-    // Prebuild large, stable dependencies by default
-    const prebuildByDefault = ['react', 'react-dom', 'lodash', 'date-fns', 'zod', '@radix-ui'];
-    return prebuildByDefault.some((pkg) => packageName.startsWith(pkg));
-}
-export class BuildProfiler {
-    profiles = new Map();
-    stack = [];
-    start(name) {
-        const profile = {
-            name,
-            startTime: Date.now(),
-            children: [],
-        };
-        if (this.stack.length > 0) {
-            const parentName = this.stack[this.stack.length - 1];
-            if (parentName) {
-                const parent = this.profiles.get(parentName);
-                if (parent) {
-                    parent.children.push(profile);
-                }
-            }
-        }
-        this.profiles.set(name, profile);
-        this.stack.push(name);
-    }
-    end(name) {
-        const profile = this.profiles.get(name);
-        if (profile) {
-            profile.endTime = Date.now();
-            profile.duration = profile.endTime - profile.startTime;
-        }
-        const index = this.stack.indexOf(name);
-        if (index !== -1) {
-            this.stack.splice(index, 1);
-        }
-    }
-    getProfile(name) {
-        return this.profiles.get(name);
-    }
-    getAllProfiles() {
-        return Array.from(this.profiles.values()).filter((p) => p.endTime !== undefined);
-    }
-    getSlowestProfiles(limit = 10) {
-        return this.getAllProfiles()
-            .sort((a, b) => (b.duration || 0) - (a.duration || 0))
-            .slice(0, limit);
-    }
-    reset() {
-        this.profiles.clear();
-        this.stack = [];
-    }
-}
-/**
- * Build optimization recommendations
- */
-export function getBuildOptimizationRecommendations(stats) {
-    const recommendations = [];
-    if (stats.duration > 30000) {
-        recommendations.push('Enable parallel builds with --parallel flag', 'Use build cache with filesystem caching', 'Consider using Turbopack for faster builds');
-    }
-    if (stats.outputSize > 500000) {
-        recommendations.push('Enable code splitting for better chunking', 'Use dynamic imports for large components', 'Enable tree shaking in production');
-    }
-    const largeAssets = stats.assets.filter((a) => a.size > 250000);
-    if (largeAssets.length > 0) {
-        recommendations.push('Compress large assets with gzip/brotli', 'Optimize images using next/image', 'Split large vendor bundles');
-    }
-    if (stats.chunks.length > 100) {
-        recommendations.push('Too many chunks - adjust splitChunks configuration', 'Increase minSize and minChunks thresholds');
-    }
-    return recommendations;
-}

package/dist/optimization/bundle-analyzer.d.ts

@@ -1,98 +0,0 @@
-/**
- * Bundle Analyzer
- *
- * Analyzes bundle size, dependencies, and optimization opportunities
- */
-export interface BundleStats {
-    totalSize: number;
-    gzipSize?: number;
-    files: BundleFile[];
-    chunks: BundleChunk[];
-    dependencies: DependencyStats[];
-    duplicates: DuplicateModule[];
-    largeFiles: BundleFile[];
-}
-export interface BundleFile {
-    path: string;
-    size: number;
-    gzipSize?: number;
-    type: string;
-    relativeSize: number;
-}
-export interface BundleChunk {
-    name: string;
-    size: number;
-    files: string[];
-    dependencies: string[];
-}
-export interface DependencyStats {
-    name: string;
-    version: string;
-    size: number;
-    instances: number;
-    treeshakeable: boolean;
-}
-export interface DuplicateModule {
-    name: string;
-    versions: string[];
-    totalSize: number;
-    locations: string[];
-}
-/**
- * Analyze bundle directory
- */
-export declare function analyzeBundleDirectory(bundlePath: string): BundleStats;
-/**
- * Format file size
- */
-export declare function formatSize(bytes: number): string;
-/**
- * Analyze webpack stats
- */
-export declare function analyzeWebpackStats(statsPath: string): BundleStats;
-/**
- * Find duplicate dependencies
- */
-export declare function findDuplicateDependencies(_stats: BundleStats): DuplicateModule[];
-/**
- * Get optimization suggestions
- */
-export interface OptimizationSuggestion {
-    type: 'bundle-split' | 'tree-shaking' | 'dynamic-import' | 'compression' | 'dependency';
-    severity: 'critical' | 'warning' | 'info';
-    message: string;
-    potentialSavings?: number;
-    file?: string;
-}
-export declare function getOptimizationSuggestions(stats: BundleStats): OptimizationSuggestion[];
-/**
- * Generate bundle report
- */
-export declare function generateBundleReport(stats: BundleStats): string;
-/**
- * Compare two bundle stats
- */
-export interface BundleComparison {
-    sizeDiff: number;
-    sizeChangePercent: number;
-    filesAdded: number;
-    filesRemoved: number;
-    filesChanged: number;
-    newLargeFiles: BundleFile[];
-    improvements: string[];
-    regressions: string[];
-}
-export declare function compareBundles(before: BundleStats, after: BundleStats): BundleComparison;
-/**
- * Get bundle health score (0-100)
- */
-export declare function getBundleHealthScore(stats: BundleStats): {
-    score: number;
-    factors: Array<{
-        name: string;
-        score: number;
-        weight: number;
-        reason: string;
-    }>;
-};
-//# sourceMappingURL=bundle-analyzer.d.ts.map

package/dist/optimization/bundle-analyzer.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bundle-analyzer.d.ts","sourceRoot":"","sources":["../../src/optimization/bundle-analyzer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAKH,MAAM,WAAW,WAAW;IAC1B,SAAS,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,UAAU,EAAE,CAAA;IACnB,MAAM,EAAE,WAAW,EAAE,CAAA;IACrB,YAAY,EAAE,eAAe,EAAE,CAAA;IAC/B,UAAU,EAAE,eAAe,EAAE,CAAA;IAC7B,UAAU,EAAE,UAAU,EAAE,CAAA;CACzB;AAED,MAAM,WAAW,UAAU;IACzB,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,YAAY,EAAE,MAAM,CAAA;CACrB;AAED,MAAM,WAAW,WAAW;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,MAAM,EAAE,CAAA;IACf,YAAY,EAAE,MAAM,EAAE,CAAA;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;IACZ,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,EAAE,OAAO,CAAA;CACvB;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,EAAE,MAAM,EAAE,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,SAAS,EAAE,MAAM,EAAE,CAAA;CACpB;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,MAAM,GAAG,WAAW,CAgDtE;AAED;;GAEG;AACH,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIhD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,CAwElE;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,WAAW,GAAG,eAAe,EAAE,CAOhF;AAED;;GAEG;AACH,MAAM,WAAW,sBAAsB;IACrC,IAAI,EAAE,cAAc,GAAG,cAAc,GAAG,gBAAgB,GAAG,aAAa,GAAG,YAAY,CAAA;IACvF,QAAQ,EAAE,UAAU,GAAG,SAAS,GAAG,MAAM,CAAA;IACzC,OAAO,EAAE,MAAM,CAAA;IACf,gBAAgB,CAAC,EAAE,MAAM,CAAA;IACzB,IAAI,CAAC,EAAE,MAAM,CAAA;CACd;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,WAAW,GAAG,sBAAsB,EAAE,CAqDvF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,GAAG,MAAM,CAmD/D;AAED;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,EAAE,MAAM,CAAA;IAChB,iBAAiB,EAAE,MAAM,CAAA;IACzB,UAAU,EAAE,MAAM,CAAA;IAClB,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,aAAa,EAAE,UAAU,EAAE,CAAA;IAC3B,YAAY,EAAE,MAAM,EAAE,CAAA;IACtB,WAAW,EAAE,MAAM,EAAE,CAAA;CACtB;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,WAAW,EAAE,KAAK,EAAE,WAAW,GAAG,gBAAgB,CA4CxF;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,WAAW,GAAG;IACxD,KAAK,EAAE,MAAM,CAAA;IACb,OAAO,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAA;CAChF,CAqDA"}

package/dist/optimization/bundle-analyzer.js

@@ -1,322 +0,0 @@
-/**
- * Bundle Analyzer
- *
- * Analyzes bundle size, dependencies, and optimization opportunities
- */
-import { readdirSync, readFileSync, statSync } from 'node:fs';
-import { extname, join, relative } from 'node:path';
-/**
- * Analyze bundle directory
- */
-export function analyzeBundleDirectory(bundlePath) {
-    const files = [];
-    let totalSize = 0;
-    // Recursively scan directory
-    function scanDirectory(dir) {
-        const entries = readdirSync(dir, { withFileTypes: true });
-        for (const entry of entries) {
-            const fullPath = join(dir, entry.name);
-            if (entry.isDirectory()) {
-                scanDirectory(fullPath);
-            }
-            else if (entry.isFile()) {
-                const stats = statSync(fullPath);
-                const relativePath = relative(bundlePath, fullPath);
-                const ext = extname(entry.name);
-                files.push({
-                    path: relativePath,
-                    size: stats.size,
-                    type: ext,
-                    relativeSize: 0, // Will calculate after total
-                });
-                totalSize += stats.size;
-            }
-        }
-    }
-    scanDirectory(bundlePath);
-    // Calculate relative sizes
-    for (const file of files) {
-        file.relativeSize = (file.size / totalSize) * 100;
-    }
-    // Find large files (>100KB)
-    const largeFiles = files.filter((f) => f.size > 100 * 1024).sort((a, b) => b.size - a.size);
-    return {
-        totalSize,
-        files,
-        chunks: [], // Would need webpack stats for this
-        dependencies: [],
-        duplicates: [],
-        largeFiles,
-    };
-}
-/**
- * Format file size
- */
-export function formatSize(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(2)} KB`;
-    return `${(bytes / (1024 * 1024)).toFixed(2)} MB`;
-}
-/**
- * Analyze webpack stats
- */
-export function analyzeWebpackStats(statsPath) {
-    const statsJson = JSON.parse(readFileSync(statsPath, 'utf-8'));
-    const files = [];
-    const chunks = [];
-    const dependencies = new Map();
-    let totalSize = 0;
-    // Process assets
-    if (statsJson.assets) {
-        for (const asset of statsJson.assets) {
-            files.push({
-                path: asset.name,
-                size: asset.size,
-                type: extname(asset.name),
-                relativeSize: 0,
-            });
-            totalSize += asset.size;
-        }
-    }
-    // Calculate relative sizes
-    for (const file of files) {
-        file.relativeSize = (file.size / totalSize) * 100;
-    }
-    // Process chunks
-    if (statsJson.chunks) {
-        for (const chunk of statsJson.chunks) {
-            chunks.push({
-                name: chunk.names?.[0] || chunk.id,
-                size: chunk.size,
-                files: chunk.files || [],
-                dependencies: [],
-            });
-        }
-    }
-    // Process modules for dependencies
-    if (statsJson.modules) {
-        for (const module of statsJson.modules) {
-            const match = module.name?.match(/node_modules\/(@?[^/]+\/[^/]+|@?[^/]+)/);
-            if (match) {
-                const pkgName = match[1];
-                const existing = dependencies.get(pkgName);
-                if (existing) {
-                    existing.instances++;
-                    existing.size += module.size || 0;
-                }
-                else {
-                    dependencies.set(pkgName, {
-                        name: pkgName,
-                        version: 'unknown',
-                        size: module.size || 0,
-                        instances: 1,
-                        treeshakeable: false,
-                    });
-                }
-            }
-        }
-    }
-    const largeFiles = files.filter((f) => f.size > 100 * 1024).sort((a, b) => b.size - a.size);
-    return {
-        totalSize,
-        files,
-        chunks,
-        dependencies: Array.from(dependencies.values()).sort((a, b) => b.size - a.size),
-        duplicates: [],
-        largeFiles,
-    };
-}
-/**
- * Find duplicate dependencies
- */
-export function findDuplicateDependencies(_stats) {
-    const _modules = new Map();
-    // This would need module resolution data
-    // Placeholder implementation
-    return [];
-}
-export function getOptimizationSuggestions(stats) {
-    const suggestions = [];
-    // Check total bundle size
-    if (stats.totalSize > 500 * 1024) {
-        suggestions.push({
-            type: 'bundle-split',
-            severity: 'critical',
-            message: `Total bundle size (${formatSize(stats.totalSize)}) exceeds 500KB. Consider code splitting.`,
-            potentialSavings: stats.totalSize - 500 * 1024,
-        });
-    }
-    // Check for large files
-    for (const file of stats.largeFiles) {
-        if (file.size > 200 * 1024) {
-            suggestions.push({
-                type: 'dynamic-import',
-                severity: 'warning',
-                message: `Large file ${file.path} (${formatSize(file.size)}). Consider lazy loading.`,
-                potentialSavings: file.size * 0.7, // Assume 70% can be deferred
-                file: file.path,
-            });
-        }
-    }
-    // Check for duplicate dependencies
-    if (stats.duplicates.length > 0) {
-        for (const dup of stats.duplicates) {
-            suggestions.push({
-                type: 'dependency',
-                severity: 'warning',
-                message: `Duplicate dependency ${dup.name} found in ${dup.versions.length} versions`,
-                potentialSavings: dup.totalSize * 0.5,
-            });
-        }
-    }
-    // Check for large dependencies
-    for (const dep of stats.dependencies) {
-        if (dep.size > 100 * 1024) {
-            suggestions.push({
-                type: 'tree-shaking',
-                severity: 'info',
-                message: `Large dependency ${dep.name} (${formatSize(dep.size)}). Verify tree shaking.`,
-            });
-        }
-    }
-    return suggestions.sort((a, b) => {
-        const severityOrder = { critical: 0, warning: 1, info: 2 };
-        return severityOrder[a.severity] - severityOrder[b.severity];
-    });
-}
-/**
- * Generate bundle report
- */
-export function generateBundleReport(stats) {
-    const suggestions = getOptimizationSuggestions(stats);
-    let report = '# Bundle Analysis Report\n\n';
-    report += `## Summary\n\n`;
-    report += `- Total Size: ${formatSize(stats.totalSize)}\n`;
-    report += `- Files: ${stats.files.length}\n`;
-    report += `- Chunks: ${stats.chunks.length}\n`;
-    report += `- Dependencies: ${stats.dependencies.length}\n`;
-    report += `- Large Files: ${stats.largeFiles.length}\n\n`;
-    if (stats.largeFiles.length > 0) {
-        report += `## Large Files (>100KB)\n\n`;
-        report += `| File | Size | % of Total |\n`;
-        report += `|------|------|------------|\n`;
-        for (const file of stats.largeFiles.slice(0, 10)) {
-            report += `| ${file.path} | ${formatSize(file.size)} | ${file.relativeSize.toFixed(1)}% |\n`;
-        }
-        report += '\n';
-    }
-    if (stats.dependencies.length > 0) {
-        report += `## Top Dependencies\n\n`;
-        report += `| Package | Size | Instances |\n`;
-        report += `|---------|------|----------|\n`;
-        for (const dep of stats.dependencies.slice(0, 10)) {
-            report += `| ${dep.name} | ${formatSize(dep.size)} | ${dep.instances} |\n`;
-        }
-        report += '\n';
-    }
-    if (suggestions.length > 0) {
-        report += `## Optimization Suggestions\n\n`;
-        for (const suggestion of suggestions) {
-            const icon = suggestion.severity === 'critical' ? '🔴' : suggestion.severity === 'warning' ? '⚠️' : 'ℹ️';
-            report += `${icon} **${suggestion.type}**: ${suggestion.message}\n`;
-            if (suggestion.potentialSavings) {
-                report += `   Potential savings: ${formatSize(suggestion.potentialSavings)}\n`;
-            }
-            report += '\n';
-        }
-    }
-    return report;
-}
-export function compareBundles(before, after) {
-    const sizeDiff = after.totalSize - before.totalSize;
-    const sizeChangePercent = (sizeDiff / before.totalSize) * 100;
-    const beforeFiles = new Set(before.files.map((f) => f.path));
-    const afterFiles = new Set(after.files.map((f) => f.path));
-    const filesAdded = after.files.filter((f) => !beforeFiles.has(f.path)).length;
-    const filesRemoved = before.files.filter((f) => !afterFiles.has(f.path)).length;
-    const filesChanged = after.files.filter((f) => {
-        const beforeFile = before.files.find((bf) => bf.path === f.path);
-        return beforeFile && beforeFile.size !== f.size;
-    }).length;
-    const newLargeFiles = after.largeFiles.filter((f) => {
-        const beforeFile = before.files.find((bf) => bf.path === f.path);
-        return !beforeFile || beforeFile.size < 100 * 1024;
-    });
-    const improvements = [];
-    const regressions = [];
-    if (sizeDiff < 0) {
-        improvements.push(`Total bundle size reduced by ${formatSize(Math.abs(sizeDiff))}`);
-    }
-    else if (sizeDiff > 0) {
-        regressions.push(`Total bundle size increased by ${formatSize(sizeDiff)}`);
-    }
-    if (after.largeFiles.length < before.largeFiles.length) {
-        improvements.push(`${before.largeFiles.length - after.largeFiles.length} fewer large files`);
-    }
-    else if (after.largeFiles.length > before.largeFiles.length) {
-        regressions.push(`${after.largeFiles.length - before.largeFiles.length} new large files`);
-    }
-    return {
-        sizeDiff,
-        sizeChangePercent,
-        filesAdded,
-        filesRemoved,
-        filesChanged,
-        newLargeFiles,
-        improvements,
-        regressions,
-    };
-}
-/**
- * Get bundle health score (0-100)
- */
-export function getBundleHealthScore(stats) {
-    const factors = [];
-    // Factor 1: Total size (40% weight)
-    let sizeScore = 100;
-    if (stats.totalSize > 1024 * 1024) {
-        sizeScore = Math.max(0, 100 - ((stats.totalSize - 1024 * 1024) / (1024 * 1024)) * 50);
-    }
-    else if (stats.totalSize > 500 * 1024) {
-        sizeScore = 100 - ((stats.totalSize - 500 * 1024) / (500 * 1024)) * 30;
-    }
-    factors.push({
-        name: 'Bundle Size',
-        score: sizeScore,
-        weight: 0.4,
-        reason: `Total size: ${formatSize(stats.totalSize)}`,
-    });
-    // Factor 2: Large files (30% weight)
-    const largeFileScore = Math.max(0, 100 - stats.largeFiles.length * 10);
-    factors.push({
-        name: 'Large Files',
-        score: largeFileScore,
-        weight: 0.3,
-        reason: `${stats.largeFiles.length} files over 100KB`,
-    });
-    // Factor 3: Chunks (20% weight)
-    const optimalChunks = 10;
-    const chunkScore = 100 - Math.abs(stats.chunks.length - optimalChunks) * 5;
-    factors.push({
-        name: 'Code Splitting',
-        score: Math.max(0, chunkScore),
-        weight: 0.2,
-        reason: `${stats.chunks.length} chunks (optimal: ~${optimalChunks})`,
-    });
-    // Factor 4: Duplicates (10% weight)
-    const duplicateScore = Math.max(0, 100 - stats.duplicates.length * 20);
-    factors.push({
-        name: 'Dependencies',
-        score: duplicateScore,
-        weight: 0.1,
-        reason: `${stats.duplicates.length} duplicate dependencies`,
-    });
-    // Calculate weighted score
-    const totalScore = factors.reduce((sum, factor) => sum + factor.score * factor.weight, 0);
-    return {
-        score: Math.round(totalScore),
-        factors,
-    };
-}