refactor(core): implement upgradeSignalToWritable utility

This function implements a common pattern/building block seen in other signal
APIs, where a base `computed` or other derived signal is made writable by
patching on a `.set` and `.update` method.

Author: alxhub

packages/core/src/core_reactivity_export_internal.ts

@@ -23,6 +23,7 @@ export {
   signal,
   WritableSignal,
   ɵunwrapWritableSignal,
+  upgradeSignalToWritable as ɵupgradeSignalToWritable,
 } from './render3/reactivity/signal';
 export {linkedSignal} from './render3/reactivity/linked_signal';
 export {untracked} from './render3/reactivity/untracked';

packages/core/src/render3/reactivity/signal.ts

@@ -16,6 +16,7 @@ import {
 } from '../../../primitives/signals';
 
 import {isSignal, Signal, ValueEqualityFn} from './api';
+import {untracked} from './untracked';
 
 /** Symbol used distinguish `WritableSignal` from other non-writable signals and functions. */
 export const ɵWRITABLE_SIGNAL: unique symbol = /* @__PURE__ */ Symbol('WRITABLE_SIGNAL');
@@ -109,3 +110,34 @@ export function signalAsReadonlyFn<T>(this: SignalGetter<T>): Signal<T> {
 export function isWritableSignal(value: unknown): value is WritableSignal<unknown> {
   return isSignal(value) && typeof (value as any).set === 'function';
 }
+
+/**
+ * Upgrade the `read` signal to be a `WritableSignal`, using the `write` function to set the value.
+ *
+ * Callers must ensure that `write` updates the value of `read` in a synchronous way.
+ *
+ * It is an error to call `upgradeSignalToWritable` on a `WritableSignal`.
+ */
+export function upgradeSignalToWritable<T>(
+  read: WritableSignal<T>,
+  write: (value: T) => void,
+): never;
+export function upgradeSignalToWritable<T>(
+  read: Signal<T>,
+  write: (value: T) => void,
+): asserts read is WritableSignal<T>;
+export function upgradeSignalToWritable<T>(
+  read: Signal<T>,
+  write: (value: T) => void,
+): asserts read is WritableSignal<T> {
+  const getter = read as WritableSignal<T>;
+  if (ngDevMode && (getter as {set?: unknown}).set) {
+    throw new Error('Cannot upgrade an already-writable signal.');
+  }
+
+  getter.set = write;
+  getter.update = (fn: (value: T) => T) => {
+    write(fn(untracked(read)));
+  };
+  getter.asReadonly = signalAsReadonlyFn;
+}

packages/core/test/signals/signal_spec.ts

@@ -6,7 +6,11 @@
  * found in the LICENSE file at https://angular.dev/license
  */
 
-import {computed, signal} from '../../src/core';
+import {
+  computed,
+  signal,
+  ɵupgradeSignalToWritable as upgradeSignalToWritable,
+} from '../../src/core';
 import {
   ReactiveHookFn,
   ReactiveNode,
@@ -224,4 +228,21 @@ describe('signals', () => {
     expect(producerKindsCreated).toEqual(['signal']);
     setPostProducerCreatedFn(prev);
   });
+
+  describe('upgradeSignalToWritable', () => {
+    it('should upgrade a signal to a writable signal', () => {
+      const celsius = signal(-40);
+      const fahrenheit = computed(() => celsius() * (9 / 5) + 32);
+      upgradeSignalToWritable(fahrenheit, (valueF) => celsius.set((valueF - 32) * (5 / 9)));
+
+      expect(celsius()).toBe(-40);
+      expect(fahrenheit()).toBe(-40);
+
+      fahrenheit.set(212);
+      expect(celsius()).toBe(0);
+
+      celsius.set(0);
+      expect(fahrenheit()).toBe(32);
+    });
+  });
 });