fix: ensure regex import groups have matching precedence

CRITICAL BUG FIXED - Regex Group Precedence:
- Problem: Regex groups didn't have priority over keyword groups
- Example: Config [Modules, /angular/] → /angular/ never matched (Modules captured everything first)
- Root cause: Groups processed in config order without precedence sorting
- Solution: Added importGroupSortForPrecedence utility

IMPLEMENTATION:
- Added importGroupSortForPrecedence() to import-utilities.ts
  - Sorts regex groups first, then keyword groups
  - Preserves original order within each category
- Updated ImportManager to use precedence sorting
  - Ensures regex groups match before keyword groups
  - Matches original TypeScript Hero behavior

NEW TESTS - Import Utilities (12 tests):
- importGroupSortForPrecedence (4 tests):
  - Prioritize regex groups, preserve order
  - Handle lists with no regex groups
  - Handle lists with only regex groups
  - Handle empty lists
- importSortByFirstSpecifier (8 tests):
  - Sort by specifier/alias/namespace
  - String imports by basename
  - Fallback to library name
  - Case-insensitive locale-aware sorting
  - Ascending/descending order

TEST COVERAGE:
- Previous: 54 tests
- Current: 66 tests (all passing ✅)

COMPATIBILITY:
✅ Ported from original TypeScript Hero utility tests
✅ Regex group precedence now works correctly
✅ All sorting utilities fully tested

Author: JohannesHoppe

mini-typescript-hero/src/imports/import-manager.ts

@@ -10,7 +10,7 @@ import {
   StringImport,
   SymbolSpecifier
 } from './import-types';
-import { importSort, importSortByFirstSpecifier, specifierSort } from './import-utilities';
+import { importSort, importSortByFirstSpecifier, specifierSort, importGroupSortForPrecedence } from './import-utilities';
 import { ImportGroup } from './import-grouping';
 
 /**
@@ -299,8 +299,12 @@ export class ImportManager {
       group.reset();
     }
 
+    // Sort groups for precedence: regex groups first, then keyword groups
+    // This ensures regex groups can match imports even if they appear later in the config
+    const groupsWithPrecedence = importGroupSortForPrecedence(importGroups);
+
     for (const imp of keep) {
-      for (const group of importGroups) {
+      for (const group of groupsWithPrecedence) {
         if (group.processImport(imp)) {
           break;
         }

mini-typescript-hero/src/imports/import-utilities.ts

@@ -1,6 +1,7 @@
 import { basename } from 'path';
 
 import { ExternalModuleImport, Import, NamedImport, NamespaceImport, StringImport, SymbolSpecifier } from './import-types';
+import { ImportGroup, RegexImportGroup } from './import-grouping';
 
 /**
  * String-Sort function.
@@ -80,3 +81,19 @@ function getImportFirstSpecifier(imp: Import): string {
 export function specifierSort(i1: SymbolSpecifier, i2: SymbolSpecifier): number {
   return stringSort(i1.specifier, i2.specifier);
 }
+
+/**
+ * Orders import groups by matching precedence (regex first).
+ * This ensures regex groups can capture imports before keyword groups,
+ * even if they appear later in the configuration.
+ *
+ * Used internally by ImportManager when assigning imports to groups.
+ */
+export function importGroupSortForPrecedence(importGroups: ImportGroup[]): ImportGroup[] {
+  const regexGroups: ImportGroup[] = [];
+  const otherGroups: ImportGroup[] = [];
+  for (const ig of importGroups) {
+    (ig instanceof RegexImportGroup ? regexGroups : otherGroups).push(ig);
+  }
+  return regexGroups.concat(otherGroups);
+}

mini-typescript-hero/src/test/imports/import-utilities.test.ts

@@ -0,0 +1,136 @@
+/**
+ * Unit Tests for Import Utilities
+ *
+ * Tests utility functions used for sorting and organizing imports.
+ * Ported from original TypeScript Hero to ensure compatibility.
+ */
+
+import * as assert from 'assert';
+import {
+  ImportGroupKeyword,
+  KeywordImportGroup,
+  RegexImportGroup
+} from '../../imports/import-grouping';
+import { importGroupSortForPrecedence, importSortByFirstSpecifier } from '../../imports/import-utilities';
+import { NamedImport, NamespaceImport, StringImport } from '../../imports/import-types';
+
+suite('Import Utilities Tests', () => {
+  suite('importGroupSortForPrecedence', () => {
+    test('should prioritize regex groups, leaving original order untouched besides that', () => {
+      const initialList = [
+        new KeywordImportGroup(ImportGroupKeyword.Modules),
+        new KeywordImportGroup(ImportGroupKeyword.Plains),
+        new RegexImportGroup('/cool-library/'),
+        new RegexImportGroup('/cooler-library/'),
+        new KeywordImportGroup(ImportGroupKeyword.Workspace),
+      ];
+
+      const result = importGroupSortForPrecedence(initialList);
+
+      // Expected: regex groups first, then keyword groups in original order
+      assert.strictEqual(result[0], initialList[2], 'First regex group should be first');
+      assert.strictEqual(result[1], initialList[3], 'Second regex group should be second');
+      assert.strictEqual(result[2], initialList[0], 'First keyword group should be third');
+      assert.strictEqual(result[3], initialList[1], 'Second keyword group should be fourth');
+      assert.strictEqual(result[4], initialList[4], 'Third keyword group should be fifth');
+    });
+
+    test('should handle list with no regex groups', () => {
+      const initialList = [
+        new KeywordImportGroup(ImportGroupKeyword.Modules),
+        new KeywordImportGroup(ImportGroupKeyword.Plains),
+        new KeywordImportGroup(ImportGroupKeyword.Workspace),
+      ];
+
+      const result = importGroupSortForPrecedence(initialList);
+
+      // Order should remain unchanged
+      assert.deepStrictEqual(result, initialList);
+    });
+
+    test('should handle list with only regex groups', () => {
+      const initialList = [
+        new RegexImportGroup('/lib-a/'),
+        new RegexImportGroup('/lib-b/'),
+        new RegexImportGroup('/lib-c/'),
+      ];
+
+      const result = importGroupSortForPrecedence(initialList);
+
+      // Order should remain unchanged
+      assert.deepStrictEqual(result, initialList);
+    });
+
+    test('should handle empty list', () => {
+      const result = importGroupSortForPrecedence([]);
+      assert.deepStrictEqual(result, []);
+    });
+  });
+
+  suite('importSortByFirstSpecifier', () => {
+    test('should sort by first specifier (named import)', () => {
+      const imp1 = new NamedImport('lib', [{ specifier: 'Zebra' }]);
+      const imp2 = new NamedImport('lib', [{ specifier: 'Apple' }]);
+
+      assert.strictEqual(importSortByFirstSpecifier(imp1, imp2), 1);
+      assert.strictEqual(importSortByFirstSpecifier(imp2, imp1), -1);
+    });
+
+    test('should sort by alias when present (named import)', () => {
+      const imp1 = new NamedImport('lib', [{ specifier: 'Foo', alias: 'Zebra' }]);
+      const imp2 = new NamedImport('lib', [{ specifier: 'Bar', alias: 'Apple' }]);
+
+      assert.strictEqual(importSortByFirstSpecifier(imp1, imp2), 1);
+      assert.strictEqual(importSortByFirstSpecifier(imp2, imp1), -1);
+    });
+
+    test('should sort namespace imports by alias', () => {
+      const imp1 = new NamespaceImport('lib', 'Zebra');
+      const imp2 = new NamespaceImport('lib', 'Apple');
+
+      assert.strictEqual(importSortByFirstSpecifier(imp1, imp2), 1);
+      assert.strictEqual(importSortByFirstSpecifier(imp2, imp1), -1);
+    });
+
+    test('should sort string imports by library basename', () => {
+      const imp1 = new StringImport('path/to/zebra');
+      const imp2 = new StringImport('path/to/apple');
+
+      assert.strictEqual(importSortByFirstSpecifier(imp1, imp2), 1);
+      assert.strictEqual(importSortByFirstSpecifier(imp2, imp1), -1);
+    });
+
+    test('should fall back to library name when no specifiers', () => {
+      const imp1 = new NamedImport('zebra-lib', []);
+      const imp2 = new NamedImport('apple-lib', []);
+
+      assert.strictEqual(importSortByFirstSpecifier(imp1, imp2), 1);
+      assert.strictEqual(importSortByFirstSpecifier(imp2, imp1), -1);
+    });
+
+    test('should sort by default alias when present', () => {
+      const imp1 = new NamedImport('lib', [], 'Zebra');
+      const imp2 = new NamedImport('lib', [], 'Apple');
+
+      assert.strictEqual(importSortByFirstSpecifier(imp1, imp2), 1);
+      assert.strictEqual(importSortByFirstSpecifier(imp2, imp1), -1);
+    });
+
+    test('should be case-insensitive (locale-aware)', () => {
+      const imp1 = new NamedImport('lib', [{ specifier: 'zebra' }]);
+      const imp2 = new NamedImport('lib', [{ specifier: 'Apple' }]);
+
+      // Should sort 'Apple' before 'zebra' (case-insensitive)
+      assert.strictEqual(importSortByFirstSpecifier(imp1, imp2), 1);
+      assert.strictEqual(importSortByFirstSpecifier(imp2, imp1), -1);
+    });
+
+    test('should handle descending order', () => {
+      const imp1 = new NamedImport('lib', [{ specifier: 'Zebra' }]);
+      const imp2 = new NamedImport('lib', [{ specifier: 'Apple' }]);
+
+      assert.strictEqual(importSortByFirstSpecifier(imp1, imp2, 'desc'), -1);
+      assert.strictEqual(importSortByFirstSpecifier(imp2, imp1, 'desc'), 1);
+    });
+  });
+});