refactor(core): expose ReactiveNode privately on signal functions (#49529)

alxhub · atscott · commit ef149defb98a · 2023-03-28T18:47:58.000-07:00
Signal functions are marked with a `[SIGNAL]` symbol property, which was previously set to `true`. This commit changes the `[SIGNAL]` property to have the `ReactiveNode` as its value instead. This doesn't change the behavior of the signal library itself, but exposes the signal internals in a way where developer tooling can look at any signal and interact with its dependency graph. PR Close #49529
diff --git a/goldens/public-api/core/index.md b/goldens/public-api/core/index.md
@@ -1361,7 +1361,7 @@ export function setTestabilityGetter(getter: GetTestability): void;
 
 // @public
 export type Signal<T> = (() => DeepReadonly<T>) & {
-    [SIGNAL]: true;
+    [SIGNAL]: unknown;
 };
 
 // @public
diff --git a/packages/core/src/signals/src/api.ts b/packages/core/src/signals/src/api.ts
@@ -6,6 +6,8 @@
  * found in the LICENSE file at https://angular.io/license
  */
 
+import {ReactiveNode} from './graph';
+
 /**
  * Symbol used to tell `Signal`s apart from other functions.
  *
@@ -24,22 +26,22 @@ const SIGNAL = Symbol('SIGNAL');
  * @developerPreview
  */
 export type Signal<T> = (() => DeepReadonly<T>)&{
-  [SIGNAL]: true;
+  [SIGNAL]: unknown;
 };
 
 /**
  * Checks if the given `value` function is a reactive `Signal`.
  */
 export function isSignal(value: Function): value is Signal<unknown> {
-  return (value as Signal<unknown>)[SIGNAL] ?? false;
+  return (value as Signal<unknown>)[SIGNAL] !== undefined;
 }
 
 /**
  * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`).
  *
  * @param fn A zero-argument function which will be converted into a `Signal`.
  */
-export function createSignalFromFunction<T>(fn: () => T): Signal<T>;
+export function createSignalFromFunction<T>(node: ReactiveNode, fn: () => T): Signal<T>;
 
 /**
  * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`), and
@@ -50,15 +52,15 @@ export function createSignalFromFunction<T>(fn: () => T): Signal<T>;
  *     desired interface for the `Signal`.
  */
 export function createSignalFromFunction<T, U extends Record<string, unknown>>(
-    fn: () => T, extraApi: U): Signal<T>&U;
+    node: ReactiveNode, fn: () => T, extraApi: U): Signal<T>&U;
 
 /**
  * Converts `fn` into a marked signal function (where `isSignal(fn)` will be `true`), and
  * potentially add some set of extra properties (passed as an object record `extraApi`).
  */
 export function createSignalFromFunction<T, U extends Record<string, unknown> = {}>(
-    fn: () => T, extraApi: U = ({} as U)): Signal<T>&U {
-  (fn as any)[SIGNAL] = true;
+    node: ReactiveNode, fn: () => T, extraApi: U = ({} as U)): Signal<T>&U {
+  (fn as any)[SIGNAL] = node;
   // Copy properties from `extraApi` to `fn` to complete the desired API of the `Signal`.
   return Object.assign(fn, extraApi) as (Signal<T>& U);
 }
diff --git a/packages/core/src/signals/src/computed.ts b/packages/core/src/signals/src/computed.ts
@@ -32,7 +32,7 @@ export function computed<T>(computation: () => T, options?: CreateComputedOption
 
   // Casting here is required for g3, as TS inference behavior is slightly different between our
   // version/options and g3's.
-  return createSignalFromFunction(node.signal.bind(node)) as unknown as Signal<T>;
+  return createSignalFromFunction(node, node.signal.bind(node)) as unknown as Signal<T>;
 }
 
 /**
diff --git a/packages/core/src/signals/src/signal.ts b/packages/core/src/signals/src/signal.ts
@@ -106,9 +106,10 @@ export interface CreateSignalOptions<T> {
  */
 export function signal<T>(initialValue: T, options?: CreateSignalOptions<T>): WritableSignal<T> {
   const signalNode = new WritableSignalImpl(initialValue, options?.equal ?? defaultEquals);
+
   // Casting here is required for g3, as TS inference behavior is slightly different between our
   // version/options and g3's.
-  const signalFn = createSignalFromFunction(signalNode.signal.bind(signalNode), {
+  const signalFn = createSignalFromFunction(signalNode, signalNode.signal.bind(signalNode), {
                      set: signalNode.set.bind(signalNode),
                      update: signalNode.update.bind(signalNode),
                      mutate: signalNode.mutate.bind(signalNode),

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ export function computed<T>(computation: () => T, options?: CreateComputedOption`
`32`	`32`
`33`	`33`	`// Casting here is required for g3, as TS inference behavior is slightly different between our`
`34`	`34`	`// version/options and g3's.`
`35`		`- return createSignalFromFunction(node.signal.bind(node)) as unknown as Signal<T>;`
	`35`	`+ return createSignalFromFunction(node, node.signal.bind(node)) as unknown as Signal<T>;`
`36`	`36`	`}`
`37`	`37`
`38`	`38`	`/**`