fix: move code

Author: BioPhoton

packages/plugin-bundle-stats/code-pushup.large-angular.config.ts

@@ -1,27 +1,27 @@
 import bundleStatsPlugin, { type GroupingRule } from './src';
 
 const nodeModulesGroup: GroupingRule[] = [
-  // General node_modules group (processed second due to reverse order)
-  { patterns: ['**/node_modules/**', '**/node_modules/@*/**/*'], icon: '📦' },
-  // Angular-specific group (processed first due to reverse order, takes precedence)
+  // General node_modules group (processed third due to reverse order)
+  {
+    patterns: ['**/node_modules/**', '**/node_modules/@*/**/*'],
+    icon: '📦',
+    maxDepth: 2,
+  },
+  // Non-scoped Angular packages (processed second due to reverse order)
   {
     patterns: [
-      '**/node_modules/@angular/**',
       '**/node_modules/ngx-*/**',
-      '**/node_modules/@ngrx/**',
       '**/node_modules/ng-*/**',
       '**/node_modules/*angular*',
     ],
     icon: '🅰️',
-    maxDepth: 3,
+    maxDepth: 2, // Gets ngx-toastr, ng-bootstrap, etc.
   },
-];
-
-const generalGroups: GroupingRule[] = [
+  // Scoped Angular packages (processed first due to reverse order, takes precedence)
   {
-    // auto derived title from result
-    patterns: ['**/packages/**'],
-    icon: '📁',
+    patterns: ['**/node_modules/@angular/**', '**/node_modules/@ngrx/**'],
+    icon: '🅰️',
+    maxDepth: 3, // Gets @angular/router, @angular/common, @ngrx/store, etc.
   },
 ];
 
@@ -243,19 +243,9 @@ const config = {
           blacklist: [],
         },
       },
-      insights: [
-        ...productGroups,
-        ...badGroups,
-        ...generalGroups,
-        ...nodeModulesGroup,
-      ],
+      insights: [...productGroups, ...badGroups, ...nodeModulesGroup],
       artefactTree: {
-        groups: [
-          ...productGroups,
-          ...badGroups,
-          ...generalGroups,
-          ...nodeModulesGroup,
-        ],
+        groups: [...productGroups, ...badGroups, ...nodeModulesGroup],
         pruning: {
           maxDepth: 5,
           minSize: 1_000, // Reduced from 50_000 to show smaller files (1KB threshold)
@@ -298,13 +288,6 @@ const config = {
           },
           artefactTree: {
             groups: [
-              {
-                title: 'Styles',
-                patterns: ['**/styles-*.css'],
-                icon: '🎨', // Add icon for styles group
-                maxDepth: 2, // Enable intermediate folder creation for nested sources
-              },
-              ...generalGroups,
               ...nodeModulesGroup,
               ...badGroups,
               ...productGroups, // Process product groups first for better specificity (last in array = first processed)

packages/plugin-bundle-stats/src/lib/runner/audits/details/table.ts

@@ -3,117 +3,36 @@ import { formatBytes } from '@code-pushup/utils';
 import type { GroupingRule } from '../../types.js';
 import type { UnifiedStats } from '../../unify/unified-stats.types.js';
 import {
-  findMatchingRule,
-  generateGroupKey,
-  matchesAnyPattern,
-} from './utils/match-pattern.js';
-import { type GroupData, createGroupManager } from './utils/table-utils.js';
+  type GroupData,
+  createGroupManager,
+  findOrCreateGroupFromRule,
+  processForTable,
+} from './utils/grouping-engine.js';
 
 const DEFAULT_GROUP_NAME = 'Group';
 const REST_GROUP_NAME = 'Rest';
 
 export type InsightsConfig = GroupingRule[];
 
-const globalRuleMatchCache = new Map<
-  string,
-  { ruleIndex: number; groupKey: string } | null
->();
-
-interface CompiledRule {
-  rule: GroupingRule;
-  matcher: (path: string) => boolean;
-  groupKeyCache: Map<string, string>;
-  ruleIndex: number;
-}
-
-export function clearRuleMatchCache(): void {
-  globalRuleMatchCache.clear();
-}
-
-function compileGroupingRules(rules: GroupingRule[]): CompiledRule[] {
-  return rules.map((rule, ruleIndex) => {
-    const { patterns } = rule;
-
-    const matcher = (filePath: string): boolean => {
-      return matchesAnyPattern(filePath, patterns, {
-        matchBase: true,
-        normalizeRelativePaths: true,
-      });
-    };
-
-    return {
-      rule,
-      matcher,
-      groupKeyCache: new Map<string, string>(),
-      ruleIndex,
-    };
-  });
-}
-
-function findMatchingCompiledRule(
-  filePath: string,
-  compiledRules: CompiledRule[],
-): CompiledRule | null {
-  const cached = globalRuleMatchCache.get(filePath);
-  if (cached !== undefined) {
-    return cached ? compiledRules[cached.ruleIndex] || null : null;
-  }
-
-  // Process rules in reverse order to match tree logic precedence
-  // More specific rules (later in array) take precedence over general ones
-  for (let i = compiledRules.length - 1; i >= 0; i--) {
-    const compiledRule = compiledRules[i];
-    if (compiledRule && compiledRule.matcher(filePath)) {
-      globalRuleMatchCache.set(filePath, {
-        ruleIndex: compiledRule.ruleIndex,
-        groupKey: '',
-      });
-      return compiledRule;
-    }
-  }
-
-  globalRuleMatchCache.set(filePath, null);
-  return null;
-}
-
-function getCachedGroupKey(
-  filePath: string,
-  compiledRule: CompiledRule,
-  preferRuleTitle: boolean = false,
-): string {
-  const globalCached = globalRuleMatchCache.get(filePath);
-  if (globalCached && globalCached.groupKey) {
-    return globalCached.groupKey;
-  }
-
-  let groupKey = compiledRule.groupKeyCache.get(filePath);
-  if (!groupKey) {
-    groupKey = generateGroupKey(filePath, compiledRule.rule, preferRuleTitle);
-    compiledRule.groupKeyCache.set(filePath, groupKey);
-
-    if (globalCached) {
-      globalCached.groupKey = groupKey;
-    }
-  }
-  return groupKey;
-}
-
-export function formatEntryPoint(title: string, icon?: string): string {
-  return icon ? `${icon} ${title}` : title;
-}
-
+/**
+ * Simplified aggregation using direct functions. Simple table grouping without engine complexity.
+ */
 export function aggregateAndSortGroups(
   statsSlice: UnifiedStats,
   insights: InsightsConfig,
-): { groups: GroupData[]; restGroup: Omit<GroupData, 'icon'> } {
+): { groups: GroupData[]; restGroup: { title: string; bytes: number } } {
   const groupingRules = insights || [];
-
-  const compiledRules = compileGroupingRules(groupingRules);
   const groupManager = createGroupManager<GroupData>();
 
+  // Pre-create groups
   for (const rule of groupingRules) {
     const effectiveTitle = rule.title || DEFAULT_GROUP_NAME;
-    groupManager.findOrCreateGroup(effectiveTitle, rule, effectiveTitle);
+    findOrCreateGroupFromRule(
+      groupManager,
+      effectiveTitle,
+      rule,
+      effectiveTitle,
+    );
   }
 
   const remainingBytesInChunks: Record<string, number> = {};
@@ -123,6 +42,7 @@ export function aggregateAndSortGroups(
     remainingBytesInChunks[key] = bytes;
   }
 
+  // Process inputs with simple functions
   for (const [outputKey, output] of outputEntries) {
     if (!output.inputs) {
       continue;
@@ -134,109 +54,106 @@ export function aggregateAndSortGroups(
         continue;
       }
 
-      const matchingCompiledRule = findMatchingCompiledRule(
+      // Use simple function for rule matching and key generation
+      const { rule, groupKey } = processForTable(
         inputPath,
-        compiledRules,
+        groupingRules,
+        true,
       );
-      if (matchingCompiledRule) {
-        // For input files, prefer rule title to support explicit titles like "Theme Park Package"
-        const groupKey = getCachedGroupKey(
-          inputPath,
-          matchingCompiledRule,
-          true,
-        );
-        const group = groupManager.findOrCreateGroup(
+      if (rule && groupKey) {
+        const group = findOrCreateGroupFromRule(
+          groupManager,
           groupKey,
-          matchingCompiledRule.rule,
-          matchingCompiledRule.rule.title || groupKey,
+          rule,
+          rule.title || groupKey,
         );
 
-        group.totalBytes += input.bytes;
+        group.bytes += input.bytes;
         remainingBytesInChunks[outputKey] =
           (remainingBytesInChunks[outputKey] || 0) - input.bytes;
       }
     }
   }
 
+  // Process outputs with simple functions
   for (const [outputKey] of outputEntries) {
     const remainingBytes = remainingBytesInChunks[outputKey];
     if (remainingBytes == null || remainingBytes <= 0) {
       continue;
     }
 
-    const matchingCompiledRule = findMatchingCompiledRule(
-      outputKey,
-      compiledRules,
-    );
-    if (matchingCompiledRule) {
-      const groupKey = getCachedGroupKey(
-        outputKey,
-        matchingCompiledRule,
-        false,
-      );
-      const group = groupManager.findOrCreateGroup(
+    const { rule, groupKey } = processForTable(outputKey, groupingRules, true);
+    if (rule && groupKey) {
+      const group = findOrCreateGroupFromRule(
+        groupManager,
         groupKey,
-        matchingCompiledRule.rule,
-        matchingCompiledRule.rule.title || groupKey,
+        rule,
+        rule.title || groupKey,
       );
 
-      group.totalBytes += remainingBytes;
+      group.bytes += remainingBytes;
       remainingBytesInChunks[outputKey] = 0;
     }
   }
 
   const restGroup = {
-    totalBytes: Object.values(remainingBytesInChunks).reduce(
+    bytes: Object.values(remainingBytesInChunks).reduce(
       (acc, bytes) => acc + bytes,
       0,
     ),
     title: REST_GROUP_NAME,
   };
 
   const groups = groupManager.getGroupsWithData();
-  groups.sort((a, b) => b.totalBytes - a.totalBytes);
+  groups.sort((a, b) => b.bytes - a.bytes);
 
   return { groups, restGroup };
 }
 
-export function formatGroupsAsTable({
-  groups,
-  restGroup,
-}: {
-  groups: GroupData[];
-  restGroup: Omit<GroupData, 'icon'>;
-}): Table {
-  const tableRows: string[][] = [];
-  for (const group of groups) {
-    const entryPoint = formatEntryPoint(group.title, group.icon);
-    const size = formatBytes(group.totalBytes);
+/**
+ * Transforms aggregated group data into table format. Creates table rows from group statistics.
+ */
+export function createTable(
+  groups: GroupData[],
+  restGroup: { title: string; bytes: number },
+): Table {
+  const rows: { group: string; modules: string; size: string }[] = [];
 
-    tableRows.push([entryPoint, size]);
+  for (const group of groups) {
+    if (group.bytes > 0) {
+      rows.push({
+        group: `${group.icon || '📁'} ${group.title}`,
+        modules: group.sources.toString(),
+        size: formatBytes(group.bytes),
+      });
+    }
   }
 
-  if (restGroup.totalBytes > 0) {
-    const entryPoint = formatEntryPoint(restGroup.title);
-    const size = formatBytes(restGroup.totalBytes);
-
-    tableRows.push([entryPoint, size]);
+  if (restGroup.bytes > 0) {
+    rows.push({
+      group: '📄 Rest',
+      modules: '-',
+      size: formatBytes(restGroup.bytes),
+    });
   }
 
   return {
     columns: [
       { key: 'group', label: 'Group', align: 'left' },
-      { key: 'size', label: 'Size', align: 'center' },
+      { key: 'modules', label: 'Modules', align: 'right' },
+      { key: 'size', label: 'Size', align: 'right' },
     ],
-    rows: tableRows.map(([group = '', size = '']) => ({
-      group,
-      size,
-    })),
+    rows,
   };
 }
 
+/**
+ * Creates insights table from stats and grouping rules. Combines aggregation and table formatting.
+ */
 export function createInsightsTable(
   statsSlice: UnifiedStats,
-  insights: GroupingRule[],
+  insights: InsightsConfig,
 ): Table {
   const { groups, restGroup } = aggregateAndSortGroups(statsSlice, insights);
-  return formatGroupsAsTable({ groups, restGroup });
+  return createTable(groups, restGroup);
 }