Test compilation shenanigans

Author: ditman

renderers/web_core/src/v0_9/reactivity/signals.angular.test.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Copyright 2026 Google LLC
  *
@@ -18,36 +17,43 @@
 import {
   signal,
   computed,
-  Signal,
-  WritableSignal,
   isSignal,
   effect,
+  Signal as NgSignal,
+  WritableSignal as NgWritableSignal,
 } from '@angular/core';
 
 import {FrameworkSignal} from './signals.js';
 import {runFrameworkSignalTests} from './signals-testing.shared.js';
 
 declare module './signals.js' {
+  // Setup the appropriate types for Angular Signals
   interface SignalKinds<T> {
-    readonly: Signal<T>;
-    writable: WritableSignal<T>;
+    // @ts-ignore : Suppress cross-compilation interface overlap
+    readonly: NgSignal<T>;
+    // @ts-ignore : Suppress cross-compilation interface overlap
+    writable: NgWritableSignal<T>;
   }
 }
 
 // Test FrameworkSignal with Angular signals explicitly mapped over SignalKinds.
 const AngularSignal = {
   computed: <T>(fn: () => T) => computed(fn),
-  isSignal: (val: unknown): val is Signal<any> => isSignal(val),
+  isSignal: (val: unknown): val is NgSignal<any> => isSignal(val),
   wrap: <T>(val: T) => signal(val),
-  unwrap: <T>(val: Signal<T>) => val(),
-  set: <T>(sig: WritableSignal<T>, value: T) => sig.set(value),
+  unwrap: <T>(val: NgSignal<T>) => val(),
+  set: <T>(sig: NgWritableSignal<T>, value: T) => sig.set(value),
   effect: (fn: () => void, cleanupCallback: () => void) => {
     const e = effect(cleanupRegisterFn => {
       cleanupRegisterFn(cleanupCallback);
       fn();
     });
     return () => e.destroy();
   },
-} satisfies FrameworkSignal;
+} as unknown as FrameworkSignal; // Bypass Mono-compilation interface overlap
+// The cast above is needed because tsc is merging all our test files together,
+// and the SignalKinds interface is being declared multiple times, causing a
+// type collision. Normally, the AngularSignal would `satisfies FrameworkSignal`,
+// and the declaration of SignalKinds wouldn't need to suppress anything.
 
 runFrameworkSignalTests('Angular implementation', AngularSignal);

renderers/web_core/src/v0_9/reactivity/signals.preact.test.ts

@@ -1,4 +1,3 @@
-// @ts-nocheck
 /**
  * Copyright 2026 Google LLC
  *
@@ -15,30 +14,32 @@
  * limitations under the License.
  */
 
-import {
-  Signal,
-  computed,
-  effect,
-} from '@preact/signals-core';
+import {computed, effect, Signal as PSignal} from '@preact/signals-core';
 
 import {FrameworkSignal} from './signals.js';
 import {runFrameworkSignalTests} from './signals-testing.shared.js';
 
 declare module './signals.js' {
   interface SignalKinds<T> {
-    readonly: Signal<T>;
-    writable: Signal<T>;
+    // @ts-ignore : Suppress cross-compilation interface overlap
+    readonly: PSignal<T>;
+    // @ts-ignore : Suppress cross-compilation interface overlap
+    writable: PSignal<T>;
   }
 }
 
 // Test FrameworkSignal with Preact signals explicitly mapped over SignalKinds.
 const PreactSignal = {
   computed: <T>(fn: () => T) => computed(fn),
-  isSignal: (val: unknown): val is Signal<any> => val instanceof Signal,
-  wrap: <T>(val: T) => new Signal(val),
-  unwrap: <T>(val: Signal<T>) => val.value,
-  set: <T>(sig: Signal<T>, value: T) => (sig.value = value),
+  isSignal: (val: unknown): val is PSignal<any> => val instanceof PSignal,
+  wrap: <T>(val: T) => new PSignal(val),
+  unwrap: <T>(val: PSignal<T>) => val.value,
+  set: <T>(sig: PSignal<T>, value: T) => (sig.value = value),
   effect: (fn: () => void) => effect(fn),
-} satisfies FrameworkSignal;
+} as unknown as FrameworkSignal; // Cast bypasses Mono-compilation interface overlap
+// The cast above is needed because tsc is merging all our test files together,
+// and the SignalKinds interface is being declared multiple times, causing a
+// type collision. Normally, the AngularSignal would `satisfies FrameworkSignal`,
+// and the declaration of SignalKinds wouldn't need to suppress anything.
 
 runFrameworkSignalTests('Preact implementation', PreactSignal);