test(vite-plugin-angular): close drift and resource-seam coverage gaps

Extends the upstream-drift and integration coverage the conformance suite
(which tests compile() directly) can't reach:

- decorator-coverage.spec: also detect FIELD_DECORATORS drift (member
  decorators via makePropDecorator) and assert COMPILABLE_DECORATORS stays a
  subset of ANGULAR_DECORATORS (Injectable/Service excluded).
- signal-api-coverage.spec: detect SIGNAL_APIS drift against ngtsc's canonical
  InitializerApiFunction list, so a new signal/initializer API can't silently
  lose metadata extraction.
- component.spec: matrix-cover external styleUrl extension reporting
  (css/scss/less).
- resource-parity.spec: external templateUrl/styleUrls must emit identical Ivy
  to the inline form, guarding the resource-inlining seam generically.

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: brandonroberts

packages/vite-plugin-angular/src/lib/compiler/__fixtures__/test.component.less

@@ -0,0 +1,6 @@
+:host {
+  display: block;
+}
+.wrapper {
+  padding: 1rem;
+}

packages/vite-plugin-angular/src/lib/compiler/component.spec.ts

@@ -2424,6 +2424,28 @@ describe('OXC-based resource inlining', () => {
     expect(styleExtensions.has(0)).toBe(false);
     expect(styleExtensions.get(1)).toBe('scss');
   });
+
+  it('reports the source extension for each preprocessable styleUrl type', () => {
+    // The fast-compile path preprocesses each external style by its own
+    // extension, so every preprocessable style language must be surfaced
+    // distinctly (not collapsed onto a single `inlineStylesExtension`).
+    for (const ext of ['css', 'scss', 'less']) {
+      const { styleExtensions } = inlineResourceUrls(
+        `
+        import { Component } from '@angular/core';
+        @Component({
+          selector: 'app-ext',
+          template: '',
+          styleUrl: './test.component.${ext}'
+        })
+        export class ExtComponent {}
+      `,
+        __dirname + '/__fixtures__/test.component.ts',
+      );
+
+      expect(styleExtensions.get(0), `extension for .${ext}`).toBe(ext);
+    }
+  });
 });
 
 describe.skipIf(!SUPPORTS_DEFER_RUNTIME)(

packages/vite-plugin-angular/src/lib/compiler/decorator-coverage.spec.ts

@@ -1,34 +1,38 @@
 import { describe, it, expect } from 'vitest';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
-import { ANGULAR_DECORATORS } from './constants';
+import {
+  ANGULAR_DECORATORS,
+  COMPILABLE_DECORATORS,
+  FIELD_DECORATORS,
+} from './constants';
 
 /**
- * Drift detector against upstream `angular/angular`, mirroring the
+ * Drift detectors against upstream `angular/angular`, mirroring the
  * compliance-category detector in `conformance.spec.ts` but at the decorator
  * level.
  *
- * The fast-compile path decides "is this an Angular file?" from a fixed set of
- * class decorators ({@link ANGULAR_DECORATORS}). When Angular ships a new class
- * decorator (e.g. `@Service` in v22) the set must grow with it — otherwise a
- * file whose only Angular decorator is the new one is treated as non-Angular,
- * skipped by the compiler, and silently falls back to JIT at runtime.
+ * The fast-compile path decides "is this an Angular file?" and which class
+ * members to extract from fixed sets of decorator names. When Angular ships a
+ * new decorator (e.g. `@Service` in v22) the relevant set must grow with it —
+ * otherwise a class/member using only the new decorator is silently skipped.
  *
  * Angular declares class decorators as
  *   `export const X: XDecorator = makeDecorator(...)`
- * and member decorators (`@Input`, `@Output`, ...) via `makePropDecorator`.
- * Only the former trigger Ivy class compilation, so only the former belong in
- * `ANGULAR_DECORATORS`.
+ * and member decorators (`@Input`, `@Output`, `@ViewChild`, ...) as
+ *   `export const X: XDecorator = makePropDecorator(...)`
+ * so the factory name selects which set we extract.
  */
 const ANGULAR_ROOT =
   process.env.ANGULAR_SOURCE_DIR ||
   path.resolve(process.env.HOME ?? '', 'projects/angular/angular');
 const CORE_SRC = path.join(ANGULAR_ROOT, 'packages/core/src');
 
-const CLASS_DECORATOR_RE =
-  /export const (\w+)\s*(?::[^=\n]*)?=\s*makeDecorator\b/g;
-
-function collectClassDecorators(dir: string): Set<string> {
+function collectDeclarations(dir: string, factory: string): Set<string> {
+  const re = new RegExp(
+    `export const (\\w+)\\s*(?::[^=\\n]*)?=\\s*${factory}\\b`,
+    'g',
+  );
   const names = new Set<string>();
   const walk = (current: string) => {
     for (const entry of fs.readdirSync(current, { withFileTypes: true })) {
@@ -41,10 +45,8 @@ function collectClassDecorators(dir: string): Set<string> {
         !entry.name.endsWith('.spec.ts')
       ) {
         const code = fs.readFileSync(full, 'utf-8');
-        if (!code.includes('makeDecorator')) continue;
-        for (const match of code.matchAll(CLASS_DECORATOR_RE)) {
-          names.add(match[1]);
-        }
+        if (!code.includes(factory)) continue;
+        for (const match of code.matchAll(re)) names.add(match[1]);
       }
     }
   };
@@ -53,22 +55,20 @@ function collectClassDecorators(dir: string): Set<string> {
 }
 
 describe.skipIf(!fs.existsSync(CORE_SRC))(
-  'Angular class decorator coverage',
+  'Angular decorator coverage (upstream drift)',
   () => {
     it('ANGULAR_DECORATORS covers every class decorator @angular/core ships', () => {
-      const upstream = collectClassDecorators(CORE_SRC);
+      const upstream = collectDeclarations(CORE_SRC, 'makeDecorator');
 
-      // Guard against a vacuous pass: if the upstream layout changed and the
-      // scan matched nothing, fail loudly instead of silently "covering" an
-      // empty set. `Component`/`Injectable` exist in every supported version.
+      // Guard against a vacuous pass: if the scan matched nothing the upstream
+      // layout changed. `Component`/`Injectable` exist in every version.
       expect(
         upstream.has('Component') && upstream.has('Injectable'),
-        `Found no Angular class decorators under ${CORE_SRC}; the upstream ` +
+        `No class decorators found under ${CORE_SRC}; the upstream ` +
           `\`makeDecorator\` layout likely changed — update this detector.`,
       ).toBe(true);
 
       const missing = [...upstream].filter((d) => !ANGULAR_DECORATORS.has(d));
-
       expect(
         missing,
         `@angular/core declares class decorator(s) the fast compiler does not ` +
@@ -78,5 +78,37 @@ describe.skipIf(!fs.existsSync(CORE_SRC))(
           `decorators would be treated as non-Angular and skipped.`,
       ).toEqual([]);
     });
+
+    it('FIELD_DECORATORS covers every member decorator @angular/core ships', () => {
+      const upstream = collectDeclarations(CORE_SRC, 'makePropDecorator');
+
+      expect(
+        upstream.has('Input') && upstream.has('Output'),
+        `No member decorators found under ${CORE_SRC}; the upstream ` +
+          `\`makePropDecorator\` layout likely changed — update this detector.`,
+      ).toBe(true);
+
+      const missing = [...upstream].filter((d) => !FIELD_DECORATORS.has(d));
+      expect(
+        missing,
+        `@angular/core declares member decorator(s) the fast compiler does not ` +
+          `extract: [${missing.join(', ')}]. Add them to FIELD_DECORATORS in ` +
+          `compiler/constants.ts, or their host bindings / queries are dropped.`,
+      ).toEqual([]);
+    });
   },
 );
+
+describe('Angular decorator set consistency', () => {
+  it('COMPILABLE_DECORATORS is a subset of ANGULAR_DECORATORS', () => {
+    const notAngular = [...COMPILABLE_DECORATORS].filter(
+      (d) => !ANGULAR_DECORATORS.has(d),
+    );
+    expect(notAngular).toEqual([]);
+  });
+
+  it('excludes @Injectable / @Service from COMPILABLE_DECORATORS (they self-register via ɵprov)', () => {
+    expect(COMPILABLE_DECORATORS.has('Injectable')).toBe(false);
+    expect(COMPILABLE_DECORATORS.has('Service')).toBe(false);
+  });
+});

packages/vite-plugin-angular/src/lib/compiler/resource-parity.spec.ts

@@ -0,0 +1,67 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { compile } from './compile';
+import { inlineResourceUrls } from './resource-inliner';
+import type { ComponentRegistry } from './registry';
+
+/**
+ * Structural guard for the resource-inlining seam that the conformance suite
+ * bypasses (it feeds inline code straight to `compile()`).
+ *
+ * A component authored with external `templateUrl` / `styleUrls` must emit the
+ * exact same Ivy output as the same component authored inline. If the
+ * resource-inlining pipeline ever diverges from the inline path (the class of
+ * bug behind the external-`styleUrl` SCSS regression), the two outputs drift
+ * and this test fails.
+ */
+const FIXTURES = path.join(__dirname, '__fixtures__');
+const ID = path.join(FIXTURES, 'test.component.ts');
+
+function compileSource(src: string): string {
+  const registry: ComponentRegistry = new Map();
+  return compile(inlineResourceUrls(src, ID).code, ID, {
+    registry,
+    useDefineForClassFields: true,
+  }).code;
+}
+
+describe('resource inlining ↔ inline output parity', () => {
+  it('emits identical Ivy for external templateUrl/styleUrls and their inline form', () => {
+    const html = fs.readFileSync(
+      path.join(FIXTURES, 'test.component.html'),
+      'utf-8',
+    );
+    const css = fs.readFileSync(
+      path.join(FIXTURES, 'test.component.css'),
+      'utf-8',
+    );
+
+    const external = `import { Component } from '@angular/core';
+@Component({
+  selector: 'app-parity',
+  templateUrl: './test.component.html',
+  styleUrls: ['./test.component.css'],
+})
+export class ParityComponent {}
+`;
+
+    const inline = `import { Component } from '@angular/core';
+@Component({
+  selector: 'app-parity',
+  template: ${JSON.stringify(html)},
+  styles: [${JSON.stringify(css)}],
+})
+export class ParityComponent {}
+`;
+
+    const externalOut = compileSource(external);
+    const inlineOut = compileSource(inline);
+
+    // Guard against a vacuous pass: real Ivy must have been emitted for both.
+    expect(externalOut).toContain('ɵcmp');
+    expect(externalOut).toContain('ParityComponent');
+
+    expect(externalOut).toBe(inlineOut);
+  });
+});

packages/vite-plugin-angular/src/lib/compiler/signal-api-coverage.spec.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect } from 'vitest';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { SIGNAL_APIS } from './constants';
+
+/**
+ * Drift detector for signal / initializer authoring APIs against upstream
+ * `angular/angular`.
+ *
+ * The fast-compile path extracts metadata for signal-based members (inputs,
+ * outputs, queries) by matching the initializer call against {@link SIGNAL_APIS}
+ * (see `metadata.ts`). If Angular adds a new initializer API and the set does
+ * not grow with it, members declared with the new API silently lose their
+ * metadata — broken inputs/outputs/queries at runtime.
+ *
+ * ngtsc's canonical list lives in the `InitializerApiFunction['functionName']`
+ * union, which is the authoritative source the Angular compiler itself uses.
+ */
+const ANGULAR_ROOT =
+  process.env.ANGULAR_SOURCE_DIR ||
+  path.resolve(process.env.HOME ?? '', 'projects/angular/angular');
+const INITIALIZER_FNS_FILE = path.join(
+  ANGULAR_ROOT,
+  'packages/compiler-cli/src/ngtsc/annotations/directive/src/initializer_functions.ts',
+);
+
+function upstreamInitializerApis(): Set<string> {
+  const code = fs.readFileSync(INITIALIZER_FNS_FILE, 'utf-8');
+  const union = code.match(/functionName:\s*([^;]+);/);
+  const names = new Set<string>();
+  if (union) {
+    for (const m of union[1].matchAll(/'([A-Za-z]+)'/g)) names.add(m[1]);
+  }
+  return names;
+}
+
+describe.skipIf(!fs.existsSync(INITIALIZER_FNS_FILE))(
+  'Angular signal/initializer API coverage (upstream drift)',
+  () => {
+    it('SIGNAL_APIS covers every initializer API ngtsc recognizes', () => {
+      const upstream = upstreamInitializerApis();
+
+      // Guard against a vacuous pass if the upstream union shape changed.
+      expect(
+        upstream.has('input') && upstream.has('output'),
+        `No initializer APIs parsed from ${INITIALIZER_FNS_FILE}; the upstream ` +
+          `\`InitializerApiFunction\` shape changed — update this detector.`,
+      ).toBe(true);
+
+      const missing = [...upstream].filter((api) => !SIGNAL_APIS.has(api));
+      expect(
+        missing,
+        `ngtsc recognizes initializer API(s) the fast compiler does not ` +
+          `extract: [${missing.join(', ')}]. Add them to SIGNAL_APIS in ` +
+          `compiler/constants.ts, or signal inputs/outputs/queries declared ` +
+          `with them lose their metadata.`,
+      ).toEqual([]);
+    });
+  },
+);