fix: use case-insensitive specifier sorting (match typescript-parser)

The old TypeScript Hero source code uses stringSort (ASCII comparison)
for specifiers, but the typescript-parser code generator overrides this
with case-insensitive sorting using toLowerCase().

This commit fixes specifierSort to use toLowerCase() + stringSort,
matching what users actually see with the old extension. Updated
unit tests accordingly.

All 389 unit tests and 203 comparison tests passing.

Author: JohannesHoppe

src/imports/import-utilities.ts

@@ -76,11 +76,18 @@ function getImportFirstSpecifier(imp: Import): string {
 }
 
 /**
- * Order specifiers by name.
- * Uses stringSort (not localeStringSort) to match old TypeScript Hero behavior.
+ * Order specifiers by name using case-insensitive comparison.
+ *
+ * NOTE: Old TypeScript Hero extension's source code uses stringSort (ASCII),
+ * but the typescript-parser code generator (namedImport.js line 19-28) overrides
+ * this with case-insensitive sorting using toLowerCase(). Since we don't use
+ * typescript-parser, we need to match what users actually see (case-insensitive).
  */
 export function specifierSort(i1: SymbolSpecifier, i2: SymbolSpecifier): number {
-  return stringSort(i1.specifier, i2.specifier);
+  // Match typescript-parser's case-insensitive sort behavior
+  const strA = i1.specifier.toLowerCase();
+  const strB = i2.specifier.toLowerCase();
+  return stringSort(strA, strB);
 }
 
 /**

tests/unit/import-manager.edge-cases-audit.test.ts

@@ -301,17 +301,16 @@ const x = A + Z;
   // B6: Unicode and case ordering
   // ============================================================================
 
-  test('B6: Unicode and mixed case specifiers (ASCII order)', async () => {
-    // Old TypeScript Hero uses stringSort (ASCII comparison) for specifiers.
-    // ASCII order for these characters: A, B, a, b, Ä, ä, Ω, α, β
-    // (Uppercase ASCII before lowercase ASCII, then extended chars by code point)
+  test('B6: Unicode and mixed case specifiers (case-insensitive)', async () => {
+    // typescript-parser uses toLowerCase() for case-insensitive sorting.
+    // Order: A/a, B/b, Ä/ä, α, β, Ω (grouped by lowercase, then by original case within ties)
     const content = `import { Ω, α, β, A, a, B, b, Ä, ä } from 'lib';
 
 const x = A + a + B + b + Ä + ä + α + β + Ω;
 `;
 
-    // ASCII sort order: A, B, a, b, Ä, ä, Ω, α, β
-    const expected = `import { A, B, a, b, Ä, ä, Ω, α, β } from 'lib';
+    // Case-insensitive sort (toLowerCase + stringSort): A, a, B, b, Ä, ä, α, β, Ω
+    const expected = `import { A, a, B, b, Ä, ä, α, β, Ω } from 'lib';
 
 const x = A + a + B + b + Ä + ä + α + β + Ω;
 `;
@@ -324,7 +323,7 @@ const x = A + a + B + b + Ä + ä + α + β + Ω;
       await applyEditsToDocument(doc, edits);
 
       const result = doc.getText();
-      assert.strictEqual(result, expected, 'Specifiers must be sorted using ASCII order (matching old extension)');
+      assert.strictEqual(result, expected, 'Specifiers must be sorted case-insensitively (matching typescript-parser)');
     } finally {
       await deleteTempDocument(doc);
     }

tests/unit/import-manager.test.ts

@@ -445,12 +445,11 @@ const y = map;
     }
   });
 
-  test('12a. Sort specifiers using ASCII order (matching old TypeScript Hero)', async () => {
-    // Old TypeScript Hero uses stringSort (ASCII comparison) for specifiers.
-    // This means uppercase letters come before lowercase (A-Z before a-z).
-    // ASCII order: Component, OnInit, inject (capitals first)
-    // localeCompare order: Component, inject, OnInit (case-insensitive)
-    // We match old extension behavior: ASCII order.
+  test('12a. Sort specifiers case-insensitively (Component, inject, OnInit)', async () => {
+    // typescript-parser code generator uses case-insensitive sorting (toLowerCase)
+    // even though old TypeScript Hero source uses stringSort (ASCII).
+    // We match what users actually see: case-insensitive alphabetical order.
+    // Case-insensitive order: Component, inject, OnInit (natural alphabetical)
     const content = `import { OnInit, Component, inject } from '@angular/core';
 
 const x = Component;
@@ -471,10 +470,10 @@ const z: OnInit = {};
       assert.ok(match, 'Should have named imports');
       const specifiers = match![1].split(',').map(s => s.trim());
 
-      // Verify ASCII order: Component, OnInit, inject (uppercase before lowercase)
-      // This matches old TypeScript Hero's stringSort behavior
-      assert.deepStrictEqual(specifiers, ['Component', 'OnInit', 'inject'],
-        'Specifiers should be sorted using ASCII order (Component, OnInit, inject) to match old extension');
+      // Verify case-insensitive order: Component, inject, OnInit
+      // This matches what typescript-parser's code generator produces
+      assert.deepStrictEqual(specifiers, ['Component', 'inject', 'OnInit'],
+        'Specifiers should be sorted case-insensitively (Component, inject, OnInit)');
     } finally {
       await deleteTempDocument(doc);
     }