@rakeyshgidwani/roger-ui-bank-theme-stan-design 0.2.9 → 0.2.11

package/dist/utils/bundle-analyzer.js

@@ -1,61 +1,65 @@
 // Bundle analysis and optimization utilities
 export interface BundleMetrics {
-  totalSize;
-  gzippedSize;
-  moduleCount;
-  chunkCount;
-  largestChunks;
-    size;
-    gzippedSize;
-    modules];
+  totalSize: number;
+  gzippedSize: number;
+  moduleCount: number;
+  chunkCount: number;
+  largestChunks: Array<{
+    name: string;
+    size: number;
+    gzippedSize: number;
+    modules: string[];
   }>;
-  duplicateModules];
-  unusedExports];
-  optimizationScore;
+  duplicateModules: string[];
+  unusedExports: string[];
+  optimizationScore: number;
 }
 
 export interface PerformanceMetrics {
-  buildTime;
-  themeSwitchTime;
-  componentRenderTime;
-  memoryUsage;
-  bundleLoadTime;
+  buildTime: number;
+  themeSwitchTime: number;
+  componentRenderTime: number;
+  memoryUsage: number;
+  bundleLoadTime: number;
 }
 
 export class BundleAnalyzer {
-  private metrics;
-  private performanceMetrics;
+  private metrics: BundleMetrics;
+  private performanceMetrics: PerformanceMetrics;
 
   constructor() {
     this.metrics = {
-      totalSize,
-      gzippedSize,
-      moduleCount,
-      chunkCount,
-      largestChunks],
-      duplicateModules],
-      unusedExports],
-      optimizationScore};
+      totalSize: 0,
+      gzippedSize: 0,
+      moduleCount: 0,
+      chunkCount: 0,
+      largestChunks: [],
+      duplicateModules: [],
+      unusedExports: [],
+      optimizationScore: 0
+    };
 
     this.performanceMetrics = {
-      buildTime,
-      themeSwitchTime,
-      componentRenderTime,
-      memoryUsage,
-      bundleLoadTime};
+      buildTime: 0,
+      themeSwitchTime: 0,
+      componentRenderTime: 0,
+      memoryUsage: 0,
+      bundleLoadTime: 0
+    };
   }
 
   // Analyze bundle size from build output
-  analyzeBundleSize(buildOutput)= buildOutput.split('\n');
+  analyzeBundleSize(buildOutput: string): BundleMetrics {
+    const lines = buildOutput.split('\n');
     let totalSize = 0;
     let gzippedSize = 0;
-    const chunks; size; gzippedSize}> = [];
+    const chunks: Array<{ name: string; size: number; gzippedSize: number }> = [];
 
     // Parse build output for size information
     lines.forEach(line => {
       if (line.includes('dist/assets/') && line.includes('kB')) {
         // Updated regex to match Vite's output format more accurately
-        const match = line.match(/dist\/assets\/([^.]+)\.[^.]+\.([^.]+)\s+(\d+\.\d+)\s+kB\s+\│\s+gzip)\s+kB/);
+        const match = line.match(/dist\/assets\/([^.]+)\.[^.]+\.([^.]+)\s+(\d+\.\d+)\s+kB\s+\│\s+gzip:\s+(\d+\.\d+)\s+kB/);
         if (match) {
           const [, name, ext, size, gzip] = match;
           const sizeKB = parseFloat(size);
@@ -65,20 +69,23 @@ export class BundleAnalyzer {
           gzippedSize += gzipKB;
           
           chunks.push({
-            name}.${ext}`,
-            size,
-            gzippedSize});
+            name: `${name}.${ext}`,
+            size: sizeKB,
+            gzippedSize: gzipKB
+          });
         } else {
-          // Fallback= line.match(/(\d+\.\d+)\s+kB/);
+          // Fallback: try to parse just the size information
+          const sizeMatch = line.match(/(\d+\.\d+)\s+kB/);
           if (sizeMatch) {
             const sizeKB = parseFloat(sizeMatch[1]);
             totalSize += sizeKB;
             gzippedSize += sizeKB * 0.3; // Estimate gzip size as 30% of original
             
             chunks.push({
-              name,
-              size,
-              gzippedSize});
+              name: 'unknown',
+              size: sizeKB,
+              gzippedSize: sizeKB * 0.3
+            });
           }
         }
       }
@@ -90,26 +97,28 @@ export class BundleAnalyzer {
     this.metrics = {
       totalSize,
       gzippedSize,
-      moduleCount),
-      chunkCount,
-      largestChunks, 5).map(chunk => ({
+      moduleCount: this.estimateModuleCount(totalSize),
+      chunkCount: chunks.length,
+      largestChunks: chunks.slice(0, 5).map(chunk => ({
         ...chunk,
-        modules)
+        modules: this.estimateModulesForChunk(chunk.name)
       })),
-      duplicateModules),
-      unusedExports),
-      optimizationScore)
+      duplicateModules: this.detectDuplicateModules(),
+      unusedExports: this.detectUnusedExports(),
+      optimizationScore: this.calculateOptimizationScore()
     };
 
     return this.metrics;
   }
 
   // Estimate module count based on bundle size
-  private estimateModuleCount(bundleSizeKB));
+  private estimateModuleCount(bundleSizeKB: number): number {
+    // Rough estimation: average module size is ~2KB
+    return Math.round(bundleSizeKB / 2);
   }
 
   // Estimate modules for a specific chunk
-  private estimateModulesForChunk(chunkName)] {
+  private estimateModulesForChunk(chunkName: string): string[] {
     // This would be more accurate with actual webpack/vite analysis
     // For now, provide reasonable estimates based on chunk names
     if (chunkName.includes('index')) {
@@ -123,21 +132,22 @@ export class BundleAnalyzer {
   }
 
   // Detect duplicate modules (simplified)
-  private detectDuplicateModules()] {
+  private detectDuplicateModules(): string[] {
     // This would require actual bundle analysis
     // For now, return common duplicates
     return ['react', 'react-dom'];
   }
 
   // Detect unused exports (simplified)
-  private detectUnusedExports()] {
+  private detectUnusedExports(): string[] {
     // This would require actual tree-shaking analysis
     // For now, return potential unused exports
     return ['legacy-theme', 'deprecated-utils'];
   }
 
   // Calculate optimization score (0-100)
-  private calculateOptimizationScore()= 100;
+  private calculateOptimizationScore(): number {
+    let score = 100;
     
     // Penalize large bundle size
     if (this.metrics.totalSize > 500) score -= 20;
@@ -156,19 +166,23 @@ export class BundleAnalyzer {
   }
 
   // Get current metrics
-  getMetrics()};
+  getMetrics(): BundleMetrics {
+    return { ...this.metrics };
   }
 
   // Get performance metrics
-  getPerformanceMetrics()};
+  getPerformanceMetrics(): PerformanceMetrics {
+    return { ...this.performanceMetrics };
   }
 
   // Measure build time
-  measureBuildTime(startTime)= Date.now() - startTime;
+  measureBuildTime(startTime: number): void {
+    this.performanceMetrics.buildTime = Date.now() - startTime;
   }
 
   // Measure theme switch performance
-  measureThemeSwitch(callback) => void)= performance.now();
+  measureThemeSwitch(callback: () => void): number {
+    const startTime = performance.now();
     callback();
     const endTime = performance.now();
     const duration = endTime - startTime;
@@ -177,7 +191,8 @@ export class BundleAnalyzer {
   }
 
   // Measure component render performance
-  measureComponentRender(callback) => void)= performance.now();
+  measureComponentRender(callback: () => void): number {
+    const startTime = performance.now();
     callback();
     const endTime = performance.now();
     const duration = endTime - startTime;
@@ -186,7 +201,8 @@ export class BundleAnalyzer {
   }
 
   // Get memory usage (if available)
-  getMemoryUsage()) {
+  getMemoryUsage(): number {
+    if ('memory' in performance) {
       const memory = (performance as any).memory;
       this.performanceMetrics.memoryUsage = memory.usedJSHeapSize / 1024 / 1024; // MB
       return this.performanceMetrics.memoryUsage;
@@ -195,8 +211,8 @@ export class BundleAnalyzer {
   }
 
   // Generate optimization recommendations
-  generateRecommendations()] {
-    const recommendations] = [];
+  generateRecommendations(): string[] {
+    const recommendations: string[] = [];
 
     if (this.metrics.totalSize > 500) {
       recommendations.push('Bundle size is large. Consider code splitting and lazy loading.');
@@ -230,10 +246,12 @@ export class BundleAnalyzer {
   }
 
   // Export metrics for external analysis
-  exportMetrics(),
-      performance,
-      recommendations),
-      timestamp).toISOString()
+  exportMetrics(): string {
+    return JSON.stringify({
+      bundle: this.metrics,
+      performance: this.performanceMetrics,
+      recommendations: this.generateRecommendations(),
+      timestamp: new Date().toISOString()
     }, null, 2);
   }
 }