Create signal implementations that satisfies FrameworkSignal. Simplify SignalKinds.

renderers/web_core/src/v0_9/reactivity/signals-testing.shared.ts

@@ -0,0 +1,57 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import assert from 'node:assert';
+import {describe, it} from 'node:test';
+import {FrameworkSignal} from './signals.js';
+
+/**
+ * Shared verification tests for FrameworkSignal implementations.
+ */
+export function runFrameworkSignalTests(name: string, SignalImpl: FrameworkSignal) {
+  describe(`FrameworkSignal ${name}`, () => {
+    it('round trip wraps and unwraps successfully', () => {
+      const val = 'hello';
+      const wrapped = SignalImpl.wrap(val);
+      assert.strictEqual(SignalImpl.unwrap(wrapped), val);
+    });
+
+    it('handles updates well', () => {
+      const signal = SignalImpl.wrap('first');
+      const computedVal = SignalImpl.computed(() => `prefix ${SignalImpl.unwrap(signal)}`);
+
+      assert.strictEqual(SignalImpl.unwrap(signal), 'first');
+      assert.strictEqual(SignalImpl.unwrap(computedVal), 'prefix first');
+
+      SignalImpl.set(signal, 'second');
+
+      assert.strictEqual(SignalImpl.unwrap(signal), 'second');
+      assert.strictEqual(SignalImpl.unwrap(computedVal), 'prefix second');
+    });
+
+    describe('.isSignal()', () => {
+      it('validates a signal', () => {
+        const val = 'hello';
+        const wrapped = SignalImpl.wrap(val);
+        assert.ok(SignalImpl.isSignal(wrapped));
+      });
+
+      it('rejects a non-signal', () => {
+        assert.strictEqual(SignalImpl.isSignal('hello'), false);
+      });
+    });
+  });
+}

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

@@ -0,0 +1,59 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {
+  signal,
+  computed,
+  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> {
+    // @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 NgSignal<any> => isSignal(val),
+  wrap: <T>(val: T) => signal(val),
+  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();
+  },
+} 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

@@ -0,0 +1,45 @@
+/**
+ * Copyright 2026 Google LLC
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+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> {
+    // @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 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),
+} 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);

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

@@ -14,37 +14,45 @@
  * limitations under the License.
  */
 
-// SignalKinds and WritableSignalKinds are declared in such a way that
+// SignalKinds is declared in such a way that
 // downstream library impls can dynamically provide their Signal implementations
 // in a type-safe way. Usage downstream might look something like:
 //
 // declare module '../reactivity/signals' {
 //   interface SignalKinds<T> {
-//     preact: Signal<T>;
-//   }
-//   interface WritableSignalKinds<T> {
-//     preact: Signal<T>;
+//     readonly: Signal<T>;
+//     writable: Signal<T>;
 //   }
 // }
 //
 // This <T>, while unused, is required to pass through to a given Signal impl.
 // eslint-disable-next-line @typescript-eslint/no-unused-vars
-export interface SignalKinds<T> {}
+export interface SignalKinds<T> {
+  _phantom?: T;
+}
 
-// This <T>, while unused, is required to pass through to a given Signal impl.
-// eslint-disable-next-line @typescript-eslint/no-unused-vars
-export interface WritableSignalKinds<T> {}
+/**
+ * A generic representation of a read-only Signal.
+ * Resolves to the specific framework's signal type if augmented.
+ */
+export type Signal<T> = SignalKinds<T> extends { readonly: infer R } ? R : unknown;
+
+/**
+ * A generic representation of a writable Signal.
+ * Resolves to the specific framework's signal type if augmented.
+ */
+export type WritableSignal<T> = SignalKinds<T> extends { writable: infer W } ? W : unknown;
 
 /**
  * A generic representation of a Signal that could come from any framework.
  * For any library building on top of A2UI's web core lib, this must be
  * implemented for their associated signals implementation.
  */
-export interface FrameworkSignal<K extends keyof SignalKinds<any>> {
+export interface FrameworkSignal {
   /**
    * Create a computed signal for this framework.
    */
-  computed<T>(fn: () => T): SignalKinds<T>[K];
+  computed<T>(fn: () => T): Signal<T>;
 
   /**
    * Run a reactive effect.
@@ -54,20 +62,20 @@ export interface FrameworkSignal<K extends keyof SignalKinds<any>> {
   /**
    * Check if an arbitrary object is a framework signal.
    */
-  isSignal(val: unknown): val is SignalKinds<any>[K];
+  isSignal(val: unknown): val is Signal<any>;
 
   /**
    * Wrap the value in a signal.
    */
-  wrap<T>(val: T): WritableSignalKinds<T>[K];
+  wrap<T>(val: T): WritableSignal<T>;
 
   /**
    * Extract the value from a signal.
    */
-  unwrap<T>(val: SignalKinds<T>[K]): T;
+  unwrap<T>(val: Signal<T>): T;
 
   /**
    * Sets the value of the provided framework signal.
    */
-  set<T>(signal: WritableSignalKinds<T>[K], value: T): void;
+  set<T>(signal: WritableSignal<T>, value: T): void;
 }