fix(@ngtools/webpack): elide imports used only in type re-exports or type declarations

When `elideImports` removes unused import specifiers (such as after
`removeIvyJitSupportCalls` removes `ɵsetClassMetadata`), it previously
walked into `interface` declarations, `type` alias declarations, and
type-only `export` declarations/specifiers (`export type { X }`,
`export { type X }`). This caused it to mark those type-only imported
symbols as used at runtime and rewrite the `ImportDeclaration` while
retaining those specifiers.

Because the `ImportDeclaration` AST node was replaced by a `before`
transformer, TypeScript skipped its own type-only import elision on the
cloned declaration, leaving the type-only specifier in the emitted JS
output. With webpack 5.112.0+, unused import specifiers are still
link-checked against the target module, causing builds with
`strictExportPresence: true` to fail.

Skip pure type declarations (`InterfaceDeclaration`,
`TypeAliasDeclaration`, `TypeParameterDeclaration`) and type-only
exports (`ExportDeclaration` and `ExportSpecifier` with `isTypeOnly`)
when collecting used identifiers in `elideImports`.

Closes #34580

Author: alan-agius4

packages/angular/build/src/tools/angular/transformers/jit-bootstrap-transformer.ts

@@ -142,6 +142,17 @@ export function elideImports(
       return;
     }
 
+    // Pure type declarations and type-only exports are erased at runtime.
+    if (
+      ts.isInterfaceDeclaration(node) ||
+      ts.isTypeAliasDeclaration(node) ||
+      ts.isTypeParameterDeclaration(node) ||
+      (ts.isExportDeclaration(node) && node.isTypeOnly) ||
+      (ts.isExportSpecifier(node) && node.isTypeOnly)
+    ) {
+      return;
+    }
+
     let symbol: ts.Symbol | undefined;
     switch (node.kind) {
       case ts.SyntaxKind.Identifier:

packages/ngtools/webpack/src/transformers/elide_imports.ts

@@ -59,6 +59,17 @@ export function elideImports(
       return;
     }
 
+    // Pure type declarations and type-only exports are erased at runtime.
+    if (
+      ts.isInterfaceDeclaration(node) ||
+      ts.isTypeAliasDeclaration(node) ||
+      ts.isTypeParameterDeclaration(node) ||
+      (ts.isExportDeclaration(node) && node.isTypeOnly) ||
+      (ts.isExportSpecifier(node) && node.isTypeOnly)
+    ) {
+      return;
+    }
+
     let symbol: ts.Symbol | undefined;
     switch (node.kind) {
       case ts.SyntaxKind.Identifier:

packages/ngtools/webpack/src/transformers/elide_imports_spec.ts

@@ -414,6 +414,47 @@ describe('elide_imports', () => {
 
       expect(tags.oneLine`${result}`).toEqual(tags.oneLine`${output}`);
     });
+
+    it('should remove import when specifiers are only used in type annotations, type-only re-exports, or interface extends', () => {
+      const input = tags.stripIndent`
+          import { Decorator } from './decorator';
+          import { OnChanges, SimpleChanges } from './type';
+          import { Service, Service2 } from './service';
+
+          export type { SimpleChanges };
+          export { type Service2 };
+          export interface ExtendedChanges extends OnChanges {
+            extra: string;
+          }
+
+          @Decorator()
+          export class Foo {
+            constructor(param: Service) {
+            }
+          }
+
+          ${dummyNode}
+        `;
+
+      const output = tags.stripIndent`
+          import { __decorate } from "tslib";
+          import { Decorator } from './decorator';
+
+          let Foo = class Foo { constructor(param) { } };
+          Foo = __decorate([ Decorator() ], Foo);
+          export { Foo };
+        `;
+
+      const { program, compilerHost } = createTypescriptContext(
+        input,
+        additionalFiles,
+        true,
+        extraCompilerOptions,
+      );
+      const result = transformTypescript(undefined, [transformer(program)], program, compilerHost);
+
+      expect(tags.oneLine`${result}`).toEqual(tags.oneLine`${output}`);
+    });
   });
 
   it('keeps jsxFactory imports when configured', () => {