fix: handle computed keys in array, tuple, generic, and parenthesized types

The computed property key collector only handled TSTypeLiteral, TSUnionType,
and TSIntersectionType. Added support for TSArrayType, TSTupleType,
TSTypeReference (generics), and TSParenthesizedType so computed keys like
`[myKey]` inside these type structures are correctly preserved.

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: Brooooooklyn

crates/oxc_angular_compiler/src/component/import_elision.rs

@@ -224,6 +224,24 @@ impl<'a> ImportElisionAnalyzer<'a> {
                     Self::collect_computed_keys_from_ts_type(ty, result);
                 }
             }
+            TSType::TSArrayType(array_type) => {
+                Self::collect_computed_keys_from_ts_type(&array_type.element_type, result);
+            }
+            TSType::TSTupleType(tuple_type) => {
+                for element in &tuple_type.element_types {
+                    Self::collect_computed_keys_from_ts_type(element.to_ts_type(), result);
+                }
+            }
+            TSType::TSTypeReference(type_ref) => {
+                if let Some(type_args) = &type_ref.type_arguments {
+                    for ty in &type_args.params {
+                        Self::collect_computed_keys_from_ts_type(ty, result);
+                    }
+                }
+            }
+            TSType::TSParenthesizedType(paren_type) => {
+                Self::collect_computed_keys_from_ts_type(&paren_type.type_annotation, result);
+            }
             _ => {}
         }
     }
@@ -1769,4 +1787,80 @@ class MyComponent {
             "myKey in type literal nested within union should be preserved"
         );
     }
+
+    #[test]
+    fn test_computed_key_in_array_type_preserved() {
+        // Review claim: TSArrayType `{ [key]: string }[]` is not handled
+        let source = r#"
+import { Component, Input } from '@angular/core';
+import { myKey } from './keys';
+
+@Component({ selector: 'test' })
+class MyComponent {
+    @Input() items: { [myKey]: string }[];
+}
+"#;
+        let type_only = analyze_source(source);
+        assert!(
+            !type_only.contains("myKey"),
+            "myKey in array element type literal should be preserved"
+        );
+    }
+
+    #[test]
+    fn test_computed_key_in_generic_type_arg_preserved() {
+        // Review claim: TSTypeReference `Array<{ [key]: string }>` is not handled
+        let source = r#"
+import { Component, Input } from '@angular/core';
+import { myKey } from './keys';
+
+@Component({ selector: 'test' })
+class MyComponent {
+    @Input() items: Array<{ [myKey]: string }>;
+}
+"#;
+        let type_only = analyze_source(source);
+        assert!(
+            !type_only.contains("myKey"),
+            "myKey in generic type argument type literal should be preserved"
+        );
+    }
+
+    #[test]
+    fn test_computed_key_in_tuple_type_preserved() {
+        // Review claim: TSTupleType is not handled
+        let source = r#"
+import { Component, Input } from '@angular/core';
+import { myKey } from './keys';
+
+@Component({ selector: 'test' })
+class MyComponent {
+    @Input() pair: [string, { [myKey]: number }];
+}
+"#;
+        let type_only = analyze_source(source);
+        assert!(
+            !type_only.contains("myKey"),
+            "myKey in tuple element type literal should be preserved"
+        );
+    }
+
+    #[test]
+    fn test_computed_key_in_parenthesized_type_preserved() {
+        // Review claim: TSParenthesizedType is not handled
+        let source = r#"
+import { Component, Input } from '@angular/core';
+import { myKey } from './keys';
+
+@Component({ selector: 'test' })
+class MyComponent {
+    @Input() data: ({ [myKey]: string });
+}
+"#;
+        let type_only = analyze_source(source);
+        assert!(
+            !type_only.contains("myKey"),
+            "myKey in parenthesized type literal should be preserved"
+        );
+    }
 }