packlyze 2.0.2 → 3.0.1

package/README.md

@@ -11,12 +11,20 @@ Advanced bundle analyzer with insights, recommendations, historical tracking, an
 ## 📊 Features
 
 - **Package Analysis**: Parse and analyze webpack, rollup, and esbuild stats files.
+- **Package-Level Insights**: Group modules by npm package to identify heavy dependencies.
 - **Smart Recommendations**: Suggestions to optimize bundle size and structure.
 - **Tree-Shaking Detection**: Identify modules and patterns that block tree-shaking.
 - **Duplicate Detection**: Find and quantify duplicate modules with potential savings.
-- **Beautiful HTML Report**: Sleek, dark-themed, responsive report with high-level metrics and deep insights.
+- **Chunk Analysis**: Analyze code-splitting efficiency and get optimization recommendations.
+- **Unused Code Detection**: Identify potentially unused modules in your bundle.
+- **Historical Tracking**: Track bundle size trends over time with `packlyze trends`.
+- **Dependency Graph**: Generate Graphviz DOT files to visualize module dependencies.
+- **Beautiful HTML Report**: Sleek, dark-themed, interactive report with search, filter, and sort.
 - **Baseline Comparison**: Compare current vs previous stats to see regressions and improvements.
+- **Multiple Export Formats**: Export to HTML, CSV, or Markdown.
+- **Config File Support**: Use `.packlyzerc` or `packlyze.config.json` for project defaults.
 - **CLI Tool**: Easy-to-use command-line interface with filters and CI-friendly thresholds.
+- **Brotli Estimates**: Get Brotli compression size estimates (17% smaller than gzip).
 - **TypeScript Ready**: Full TypeScript support with type definitions.
 
 ## 🚀 Quick Start
@@ -201,6 +209,32 @@ packlyze analyze dist/stats.json \
   --no-html
 ```
 
+### Historical tracking
+
+Track bundle size over time:
+
+```bash
+# Automatically saves to .packlyze/history.json after each analysis
+packlyze analyze stats.json
+
+# View trends
+packlyze trends
+
+# View more entries
+packlyze trends --limit 20
+```
+
+### Dependency graph
+
+Generate a dependency graph visualization:
+
+```bash
+packlyze analyze stats.json --dependency-graph graph.dot
+
+# Render with Graphviz
+dot -Tsvg graph.dot -o graph.svg
+```
+
 ## 🎯 Use Cases
 
 Common scenarios where Packlyze is helpful:

package/dist/analyzer/packlyze.d.ts

@@ -2,8 +2,11 @@ import { AnalysisResult } from '../types.js';
 export declare class Packlyze {
     private statsData;
     private baseDir;
-    constructor(statsPath: string);
+    private verboseLog?;
+    constructor(statsPath: string, verboseLog?: (message: string) => void);
+    private log;
     private loadStats;
+    private validateStats;
     analyze(): Promise<AnalysisResult>;
     private extractBundleStats;
     private getTotalSize;
@@ -12,7 +15,18 @@ export declare class Packlyze {
     private getInitialBundleSize;
     private generateRecommendations;
     private detectTreeshakingIssues;
+    /**
+     * Extract package name from module path.
+     * Handles node_modules paths like:
+     * - node_modules/lodash/index.js -> lodash
+     * - node_modules/@types/node/index.d.ts -> @types/node
+     * - node_modules/react-dom/client.js -> react-dom
+     */
+    private extractPackageName;
     private findDuplicates;
+    private analyzePackages;
+    private detectUnusedModules;
+    private analyzeChunks;
     private calculateMetrics;
 }
 //# sourceMappingURL=packlyze.d.ts.map

package/dist/analyzer/packlyze.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"packlyze.d.ts","sourceRoot":"","sources":["../../src/analyzer/packlyze.ts"],"names":[],"mappings":"AAEA,OAAO,EAOL,cAAc,EACf,MAAM,aAAa,CAAC;AAErB,qBAAa,QAAQ;IACnB,OAAO,CAAC,SAAS,CAcV;IACP,OAAO,CAAC,OAAO,CAAS;gBAEZ,SAAS,EAAE,MAAM;IAQ7B,OAAO,CAAC,SAAS;IASX,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;IAiBxC,OAAO,CAAC,kBAAkB;IAwB1B,OAAO,CAAC,YAAY;IAKpB,OAAO,CAAC,gBAAgB;IAKxB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,uBAAuB;IAkD/B,OAAO,CAAC,uBAAuB;IAY/B,OAAO,CAAC,cAAc;IAyBtB,OAAO,CAAC,gBAAgB;CAkBzB"}
+{"version":3,"file":"packlyze.d.ts","sourceRoot":"","sources":["../../src/analyzer/packlyze.ts"],"names":[],"mappings":"AAEA,OAAO,EAUL,cAAc,EACf,MAAM,aAAa,CAAC;AAErB,qBAAa,QAAQ;IACnB,OAAO,CAAC,SAAS,CAcV;IACP,OAAO,CAAC,OAAO,CAAS;IACxB,OAAO,CAAC,UAAU,CAAC,CAA4B;gBAEnC,SAAS,EAAE,MAAM,EAAE,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI;IASrE,OAAO,CAAC,GAAG;IAMX,OAAO,CAAC,SAAS;IA8BjB,OAAO,CAAC,aAAa;IA0Cf,OAAO,IAAI,OAAO,CAAC,cAAc,CAAC;IAuCxC,OAAO,CAAC,kBAAkB;IAqG1B,OAAO,CAAC,YAAY;IA2CpB,OAAO,CAAC,gBAAgB;IAuCxB,OAAO,CAAC,aAAa;IAUrB,OAAO,CAAC,oBAAoB;IAM5B,OAAO,CAAC,uBAAuB;IAkD/B,OAAO,CAAC,uBAAuB;IAmB/B;;;;;;OAMG;IACH,OAAO,CAAC,kBAAkB;IAc1B,OAAO,CAAC,cAAc;IAoCtB,OAAO,CAAC,eAAe;IAqCvB,OAAO,CAAC,mBAAmB;IAkD3B,OAAO,CAAC,aAAa;IAgErB,OAAO,CAAC,gBAAgB;CAuBzB"}

package/dist/analyzer/packlyze.js

@@ -7,53 +7,200 @@ exports.Packlyze = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 class Packlyze {
-    constructor(statsPath) {
+    constructor(statsPath, verboseLog) {
         this.statsData = {};
+        this.verboseLog = verboseLog;
         if (!fs_1.default.existsSync(statsPath)) {
             throw new Error(`Stats file not found: ${statsPath}`);
         }
         this.baseDir = path_1.default.dirname(statsPath);
         this.loadStats(statsPath);
     }
+    log(message) {
+        if (this.verboseLog) {
+            this.verboseLog(message);
+        }
+    }
     loadStats(statsPath) {
+        this.log('Reading stats file...');
         const content = fs_1.default.readFileSync(statsPath, 'utf-8');
+        this.log(`Stats file size: ${(content.length / 1024).toFixed(2)} KB`);
         try {
+            this.log('Parsing JSON...');
             this.statsData = JSON.parse(content);
+            this.log('Validating stats structure...');
+            this.validateStats();
+            // Count modules from different sources
+            const topLevelModules = this.statsData.modules?.length || 0;
+            const chunks = this.statsData.chunks || [];
+            let chunkModules = 0;
+            chunks.forEach((chunk) => {
+                if (Array.isArray(chunk.modules)) {
+                    chunkModules += chunk.modules.length;
+                }
+            });
+            this.log(`Found ${topLevelModules} top-level modules, ${chunkModules} modules in chunks, ${chunks.length} chunks`);
         }
         catch (e) {
+            if (e instanceof Error && e.message.includes('Invalid stats')) {
+                throw e;
+            }
             throw new Error(`Invalid JSON in stats file: ${e}`);
         }
     }
+    validateStats() {
+        if (!this.statsData || typeof this.statsData !== 'object') {
+            throw new Error('Invalid stats: stats file must be a valid JSON object');
+        }
+        // Check for required structure (at least one of assets, modules, or chunks should exist)
+        const hasAssets = Array.isArray(this.statsData.assets);
+        const hasModules = Array.isArray(this.statsData.modules);
+        const hasChunks = Array.isArray(this.statsData.chunks);
+        if (!hasAssets && !hasModules && !hasChunks) {
+            throw new Error('Invalid stats: stats file must contain at least one of: assets, modules, or chunks arrays. ' +
+                'Ensure you generated the stats file correctly (e.g., webpack --profile --json stats.json)');
+        }
+        // Validate modules if present
+        if (hasModules && Array.isArray(this.statsData.modules)) {
+            for (const module of this.statsData.modules) {
+                if (module && typeof module !== 'object') {
+                    throw new Error('Invalid stats: all modules must be objects');
+                }
+                if (module && module.size !== undefined && (typeof module.size !== 'number' || module.size < 0)) {
+                    throw new Error('Invalid stats: module sizes must be non-negative numbers');
+                }
+            }
+        }
+        // Validate assets if present
+        if (hasAssets && Array.isArray(this.statsData.assets)) {
+            for (const asset of this.statsData.assets) {
+                if (asset && typeof asset !== 'object') {
+                    throw new Error('Invalid stats: all assets must be objects');
+                }
+                if (asset && asset.size !== undefined && (typeof asset.size !== 'number' || asset.size < 0)) {
+                    throw new Error('Invalid stats: asset sizes must be non-negative numbers');
+                }
+            }
+        }
+    }
     async analyze() {
+        this.log('Extracting bundle statistics...');
         const bundleStats = this.extractBundleStats();
+        this.log('Analyzing packages...');
+        const packages = this.analyzePackages(bundleStats);
+        this.log('Detecting duplicate modules...');
+        const duplicates = this.findDuplicates(bundleStats);
+        this.log('Detecting tree-shaking issues...');
+        const treeshakingIssues = this.detectTreeshakingIssues(bundleStats);
+        this.log('Generating recommendations...');
         const recommendations = this.generateRecommendations(bundleStats);
-        const treeshakingIssues = this.detectTreeshakingIssues();
-        const duplicates = this.findDuplicates();
+        this.log('Calculating metrics...');
         const metrics = this.calculateMetrics(bundleStats);
+        this.log('Analyzing chunks...');
+        const chunkAnalysis = this.analyzeChunks(bundleStats);
+        this.log('Detecting unused modules...');
+        const unusedModules = this.detectUnusedModules(bundleStats);
+        this.log('Analysis complete!');
         return {
             bundleStats,
             recommendations,
             treeshakingIssues,
             duplicates,
+            packages,
+            chunkAnalysis,
+            unusedModules,
             metrics,
             timestamp: new Date().toISOString()
         };
     }
     extractBundleStats() {
         const assets = this.statsData.assets || [];
-        const modules = (this.statsData.modules || []).map((m) => ({
-            name: m.name || 'unknown',
-            size: m.size || 0,
-            gzipSize: m.gzipSize,
-            percentage: (m.size || 0) / this.getTotalSize() * 100,
-            reasons: Array.isArray(m.reasons)
-                ? m.reasons.map((r) => typeof r === 'string' ? r : r.moduleName ?? '')
-                : []
+        // Extract modules from top-level or from chunks (webpack 5+ format)
+        let modules = [];
+        // First, try top-level modules array
+        if (Array.isArray(this.statsData.modules) && this.statsData.modules.length > 0) {
+            modules = this.statsData.modules.map((m) => ({
+                name: m.name || 'unknown',
+                size: m.size || 0,
+                gzipSize: m.gzipSize,
+                percentage: 0, // Will calculate after we know total size
+                reasons: Array.isArray(m.reasons)
+                    ? m.reasons.map((r) => typeof r === 'string' ? r : r.moduleName ?? '')
+                    : []
+            }));
+        }
+        else {
+            // Extract modules from chunks (webpack 5+ format)
+            const moduleMap = new Map();
+            const chunks = this.statsData.chunks || [];
+            chunks.forEach((chunk) => {
+                if (Array.isArray(chunk.modules)) {
+                    chunk.modules.forEach((m) => {
+                        // Handle both object and string formats
+                        let moduleName;
+                        let moduleSize;
+                        let moduleGzipSize;
+                        let moduleReasons;
+                        if (typeof m === 'string') {
+                            // Module is just a name string
+                            moduleName = m;
+                            moduleSize = 0; // Size unknown, will be calculated from chunk or assets
+                            moduleGzipSize = undefined;
+                            moduleReasons = [];
+                        }
+                        else {
+                            // Module is an object
+                            moduleName = m.name || 'unknown';
+                            moduleSize = m.size || 0;
+                            moduleGzipSize = m.gzipSize;
+                            moduleReasons = m.reasons;
+                        }
+                        if (!moduleMap.has(moduleName)) {
+                            moduleMap.set(moduleName, {
+                                name: moduleName,
+                                size: moduleSize,
+                                gzipSize: moduleGzipSize,
+                                percentage: 0,
+                                reasons: Array.isArray(moduleReasons)
+                                    ? moduleReasons.map((r) => typeof r === 'string' ? r : r.moduleName ?? '')
+                                    : []
+                            });
+                        }
+                        else {
+                            // If module appears in multiple chunks, use the maximum size (not sum)
+                            // because the same module shouldn't be counted multiple times
+                            const existing = moduleMap.get(moduleName);
+                            existing.size = Math.max(existing.size, moduleSize);
+                            if (moduleGzipSize) {
+                                existing.gzipSize = existing.gzipSize ? Math.max(existing.gzipSize, moduleGzipSize) : moduleGzipSize;
+                            }
+                            // Merge reasons if available
+                            if (Array.isArray(moduleReasons) && moduleReasons.length > 0) {
+                                const existingReasons = new Set(existing.reasons);
+                                moduleReasons.forEach((r) => {
+                                    const reasonStr = typeof r === 'string' ? r : r.moduleName ?? '';
+                                    if (reasonStr)
+                                        existingReasons.add(reasonStr);
+                                });
+                                existing.reasons = Array.from(existingReasons);
+                            }
+                        }
+                    });
+                }
+            });
+            modules = Array.from(moduleMap.values());
+        }
+        // Calculate total size from assets or modules
+        const totalSize = this.getTotalSize() || modules.reduce((sum, m) => sum + (m.size || 0), 0);
+        // Calculate percentages
+        modules = modules.map((m) => ({
+            ...m,
+            percentage: totalSize > 0 ? ((m.size || 0) / totalSize) * 100 : 0
         }));
         return {
             name: this.statsData.name || 'bundle',
-            size: this.getTotalSize(),
-            gzipSize: this.getTotalGzipSize(),
+            size: totalSize,
+            gzipSize: this.getTotalGzipSize() || modules.reduce((sum, m) => sum + (m.gzipSize || 0), 0),
             modules: modules.sort((a, b) => b.size - a.size),
             chunks: this.extractChunks(),
             isInitialBySize: this.getInitialBundleSize(),
@@ -63,11 +210,71 @@ class Packlyze {
     }
     getTotalSize() {
         const assets = this.statsData.assets || [];
-        return assets.reduce((sum, asset) => sum + (asset.size || 0), 0);
+        const assetSize = assets.reduce((sum, asset) => sum + (asset.size || 0), 0);
+        // If assets are empty or zero, try to calculate from modules
+        if (assetSize === 0) {
+            // Try top-level modules
+            if (Array.isArray(this.statsData.modules) && this.statsData.modules.length > 0) {
+                return this.statsData.modules.reduce((sum, m) => sum + (m.size || 0), 0);
+            }
+            // Try modules from chunks
+            const chunks = this.statsData.chunks || [];
+            let moduleSize = 0;
+            const seenModules = new Set();
+            chunks.forEach((chunk) => {
+                if (Array.isArray(chunk.modules)) {
+                    chunk.modules.forEach((m) => {
+                        const moduleName = m.name || 'unknown';
+                        // Only count each module once (in case it appears in multiple chunks)
+                        if (!seenModules.has(moduleName)) {
+                            seenModules.add(moduleName);
+                            moduleSize += (m.size || 0);
+                        }
+                    });
+                }
+            });
+            if (moduleSize > 0) {
+                return moduleSize;
+            }
+            // Try chunk sizes as fallback
+            const chunkSize = chunks.reduce((sum, c) => sum + (c.size || 0), 0);
+            if (chunkSize > 0) {
+                return chunkSize;
+            }
+        }
+        return assetSize;
     }
     getTotalGzipSize() {
         const assets = this.statsData.assets || [];
-        return assets.reduce((sum, asset) => sum + (asset.gzipSize || 0), 0);
+        const assetGzipSize = assets.reduce((sum, asset) => sum + (asset.gzipSize || 0), 0);
+        // If assets are empty or zero, try to calculate from modules
+        if (assetGzipSize === 0) {
+            // Try top-level modules
+            if (Array.isArray(this.statsData.modules) && this.statsData.modules.length > 0) {
+                return this.statsData.modules.reduce((sum, m) => sum + (m.gzipSize || 0), 0);
+            }
+            // Try modules from chunks
+            const chunks = this.statsData.chunks || [];
+            let moduleGzipSize = 0;
+            const seenModules = new Set();
+            chunks.forEach((chunk) => {
+                if (Array.isArray(chunk.modules)) {
+                    chunk.modules.forEach((m) => {
+                        const moduleName = m.name || 'unknown';
+                        if (!seenModules.has(moduleName)) {
+                            seenModules.add(moduleName);
+                            moduleGzipSize += (m.gzipSize || 0);
+                        }
+                    });
+                }
+            });
+            if (moduleGzipSize > 0) {
+                return moduleGzipSize;
+            }
+            // Try chunk gzip sizes as fallback
+            return chunks.reduce((sum, c) => sum + (c.gzipSize || 0), 0);
+        }
+        return assetGzipSize;
     }
     extractChunks() {
         return (this.statsData.chunks || []).map((chunk) => ({
@@ -110,7 +317,7 @@ class Packlyze {
             });
         }
         // Duplicate check
-        const duplicates = this.findDuplicates();
+        const duplicates = this.findDuplicates(stats);
         if (duplicates.length > 0) {
             recommendations.push({
                 severity: 'warning',
@@ -128,45 +335,210 @@ class Packlyze {
         }
         return recommendations;
     }
-    detectTreeshakingIssues() {
+    detectTreeshakingIssues(stats) {
         const issues = [];
-        const modules = this.statsData.modules || [];
-        modules.forEach((m) => {
-            if (typeof m.source === 'string' && (m.source.includes('module.exports') || m.source.includes('require('))) {
+        // Check modules from BundleStats (which includes extracted modules)
+        stats.modules.forEach((m) => {
+            // Try to get source from original stats data
+            const originalModule = Array.isArray(this.statsData.modules)
+                ? this.statsData.modules.find((om) => om.name === m.name)
+                : null;
+            if (originalModule && typeof originalModule.source === 'string' &&
+                (originalModule.source.includes('module.exports') || originalModule.source.includes('require('))) {
                 issues.push(`${m.name}: Uses CommonJS - reduces tree-shaking effectiveness`);
             }
         });
         return issues.slice(0, 10); // Limit to top 10
     }
-    findDuplicates() {
-        const moduleMap = new Map();
+    /**
+     * Extract package name from module path.
+     * Handles node_modules paths like:
+     * - node_modules/lodash/index.js -> lodash
+     * - node_modules/@types/node/index.d.ts -> @types/node
+     * - node_modules/react-dom/client.js -> react-dom
+     */
+    extractPackageName(modulePath) {
+        if (!modulePath)
+            return null;
+        // Match node_modules packages
+        const nodeModulesMatch = modulePath.match(/node_modules[/\\](@[^/\\]+[/\\][^/\\]+|[^/\\]+)/);
+        if (nodeModulesMatch) {
+            return nodeModulesMatch[1].replace(/[/\\]/g, '/');
+        }
+        // For non-node_modules paths, use basename as fallback
+        // This helps catch duplicates in source code (e.g., utils/helper.js and components/helper.js)
+        return path_1.default.basename(modulePath);
+    }
+    findDuplicates(stats) {
+        // Group by package name (for node_modules) or basename (for source files)
+        const packageMap = new Map();
         const duplicates = [];
-        (this.statsData.modules || []).forEach((module) => {
-            const baseName = path_1.default.basename(module.name || '');
-            if (!moduleMap.has(baseName)) {
-                moduleMap.set(baseName, []);
+        stats.modules.forEach((module) => {
+            const moduleName = module.name || '';
+            const packageName = this.extractPackageName(moduleName) || 'unknown';
+            if (!packageMap.has(packageName)) {
+                packageMap.set(packageName, []);
             }
-            moduleMap.get(baseName).push(module);
+            packageMap.get(packageName).push(module);
         });
-        moduleMap.forEach((modules) => {
+        // Find actual duplicates (same package/module appearing multiple times)
+        packageMap.forEach((modules) => {
             if (modules.length > 1) {
-                const totalSize = modules.reduce((s, m) => s + (m.size || 0), 0);
-                const minSize = Math.min(...modules.map(m => m.size || 0));
-                duplicates.push({
-                    names: modules.map(m => m.name),
-                    totalSize,
-                    savings: totalSize - minSize
-                });
+                // Only consider it a duplicate if the modules have different full paths
+                // (same package imported from different locations)
+                const uniquePaths = new Set(modules.map(m => m.name));
+                if (uniquePaths.size > 1) {
+                    const totalSize = modules.reduce((s, m) => s + (m.size || 0), 0);
+                    const minSize = Math.min(...modules.map(m => m.size || 0));
+                    duplicates.push({
+                        names: modules.map(m => m.name),
+                        totalSize,
+                        savings: totalSize - minSize
+                    });
+                }
             }
         });
         return duplicates.sort((a, b) => b.totalSize - a.totalSize).slice(0, 10);
     }
+    analyzePackages(stats) {
+        const packageMap = new Map();
+        const bundleTotalSize = stats.size;
+        stats.modules.forEach((module) => {
+            const packageName = this.extractPackageName(module.name);
+            if (!packageName)
+                return;
+            if (!packageMap.has(packageName)) {
+                packageMap.set(packageName, { modules: [], totalGzip: 0 });
+            }
+            const pkg = packageMap.get(packageName);
+            pkg.modules.push(module);
+            if (module.gzipSize) {
+                pkg.totalGzip += module.gzipSize;
+            }
+        });
+        const packages = [];
+        packageMap.forEach((pkg, name) => {
+            const packageTotalSize = pkg.modules.reduce((sum, m) => sum + m.size, 0);
+            packages.push({
+                name,
+                totalSize: packageTotalSize,
+                gzipSize: pkg.totalGzip > 0 ? pkg.totalGzip : undefined,
+                moduleCount: pkg.modules.length,
+                modules: pkg.modules.map(m => m.name),
+                percentage: bundleTotalSize > 0 ? (packageTotalSize / bundleTotalSize) * 100 : 0
+            });
+        });
+        return packages
+            .sort((a, b) => b.totalSize - a.totalSize)
+            .slice(0, 20); // Top 20 packages
+    }
+    detectUnusedModules(stats) {
+        const unused = [];
+        const importedModules = new Set();
+        // Build set of all modules that are imported by others
+        stats.modules.forEach(module => {
+            const reasons = Array.isArray(module.reasons) ? module.reasons : [];
+            reasons.forEach(reason => {
+                // Extract module name from reason (format varies by bundler)
+                if (typeof reason === 'string' && reason !== 'entry' && reason !== 'cjs require') {
+                    // Try to extract module path from reason
+                    const match = reason.match(/([^\s]+\.(js|ts|jsx|tsx))/);
+                    if (match && match[1]) {
+                        importedModules.add(match[1]);
+                    }
+                }
+            });
+        });
+        // Find modules that are not entry points and not imported
+        stats.modules.forEach(module => {
+            const reasons = Array.isArray(module.reasons) ? module.reasons : [];
+            const isEntry = reasons.some(r => {
+                const reasonStr = typeof r === 'string' ? r : String(r);
+                return reasonStr === 'entry' || reasonStr.includes('entry');
+            });
+            const isImported = importedModules.has(module.name);
+            if (!isEntry && !isImported && (module.size || 0) > 0) {
+                // Additional check: module might be in a chunk but not actually used
+                const inChunk = stats.chunks.some(chunk => {
+                    const chunkModules = Array.isArray(chunk.modules) ? chunk.modules : [];
+                    return chunkModules.includes(module.name);
+                });
+                if (inChunk) {
+                    unused.push({
+                        name: module.name || 'unknown',
+                        size: module.size || 0,
+                        reason: 'Module in bundle but no clear import path detected'
+                    });
+                }
+            }
+        });
+        return unused
+            .sort((a, b) => b.size - a.size)
+            .slice(0, 20); // Top 20 potentially unused modules
+    }
+    analyzeChunks(stats) {
+        const chunks = stats.chunks;
+        if (chunks.length === 0) {
+            return {
+                averageChunkSize: 0,
+                averageModulesPerChunk: 0,
+                largestChunk: { id: 0, name: 'N/A', size: 0, modules: [] },
+                smallestChunk: { id: 0, name: 'N/A', size: 0, modules: [] },
+                initialChunkSize: 0,
+                recommendations: []
+            };
+        }
+        const chunkSizes = chunks.map(c => c.size || 0);
+        const totalChunkSize = chunkSizes.reduce((a, b) => a + b, 0);
+        const averageChunkSize = chunks.length > 0 ? totalChunkSize / chunks.length : 0;
+        const modulesPerChunk = chunks.map(c => (c.modules && Array.isArray(c.modules)) ? c.modules.length : 0);
+        const totalModules = modulesPerChunk.reduce((a, b) => a + b, 0);
+        const averageModulesPerChunk = chunks.length > 0 ? totalModules / chunks.length : 0;
+        const sortedBySize = [...chunks].sort((a, b) => (b.size || 0) - (a.size || 0));
+        const largestChunk = sortedBySize[0] || { id: 0, name: 'N/A', size: 0, modules: [] };
+        const smallestChunk = sortedBySize[sortedBySize.length - 1] || { id: 0, name: 'N/A', size: 0, modules: [] };
+        const initialChunks = chunks.filter(c => {
+            // Try to identify initial chunks
+            const chunkInfo = stats.chunks.find(ch => ch.id === c.id);
+            return chunkInfo && 'initial' in chunkInfo && chunkInfo.initial === true;
+        });
+        const initialChunkSize = initialChunks.reduce((sum, c) => sum + (c.size || 0), 0);
+        const recommendations = [];
+        // Large chunks recommendation
+        if (averageChunkSize > 500000) {
+            recommendations.push(`Average chunk size is ${(averageChunkSize / 1024).toFixed(2)}KB - consider splitting large chunks`);
+        }
+        // Too many small chunks
+        if (chunks.length > 20 && averageChunkSize < 50000) {
+            recommendations.push(`Many small chunks (${chunks.length}) - consider combining related chunks`);
+        }
+        // Initial chunk too large
+        if (initialChunkSize > 500000) {
+            recommendations.push(`Initial chunk is ${(initialChunkSize / 1024).toFixed(2)}KB - implement code-splitting for better load times`);
+        }
+        // Chunk size imbalance
+        if (smallestChunk.size > 0 && largestChunk.size > smallestChunk.size * 10) {
+            recommendations.push(`Chunk size imbalance detected - largest chunk is ${(largestChunk.size / smallestChunk.size).toFixed(1)}x larger than smallest`);
+        }
+        return {
+            averageChunkSize,
+            averageModulesPerChunk,
+            largestChunk,
+            smallestChunk,
+            initialChunkSize,
+            recommendations
+        };
+    }
     calculateMetrics(stats) {
         const sizes = stats.modules.map(m => m.size);
         const averageSize = sizes.length > 0 ? sizes.reduce((a, b) => a + b, 0) / sizes.length : 0;
+        const gzipSize = stats.gzipSize || 0;
+        // Brotli is typically 15-20% smaller than gzip, estimate at 17% reduction
+        const brotliSize = gzipSize > 0 ? Math.round(gzipSize * 0.83) : undefined;
         return {
             totalSize: stats.size,
-            totalGzipSize: stats.gzipSize || 0,
+            totalGzipSize: gzipSize,
+            totalBrotliSize: brotliSize,
             moduleCount: stats.modules.length,
             chunkCount: stats.chunks.length,
             largestModule: stats.modules[0] || {