feat: add computed peek (#66)

Co-authored-by: JounQin <[email protected]>

Author: teleskop150750

.changeset/neat-dots-hug.md

@@ -0,0 +1,10 @@
+---
+'unuse-reactivity': minor
+'unuse': minor
+'unuse-angular': minor
+'unuse-react': minor
+'unuse-solid': minor
+'unuse-vue': minor
+---
+
+feat: add computed peek

packages/unuse-reactivity/src/unComputed/index.spec.ts

@@ -1,5 +1,6 @@
 import { describe, expect, it, vi } from 'vitest';
 import { isUnComputed, UN_COMPUTED, unComputed } from '.';
+import { unEffect } from '../unEffect';
 import { unSignal } from '../unSignal';
 
 describe('unComputed', () => {
@@ -13,6 +14,7 @@ describe('unComputed', () => {
 
     expect(myComputed).toBeTypeOf('object');
     expect(myComputed.get).toBeTypeOf('function');
+    expect(myComputed.peek).toBeTypeOf('function');
     expect(isUnComputed(myComputed)).toBe(true);
   });
 
@@ -64,6 +66,23 @@ describe('unComputed', () => {
     expect(fnSpy).toHaveBeenCalledTimes(2);
   });
 
+  it('should peek the current value without triggering effects', () => {
+    const fn1Spy = vi.fn();
+
+    const mySignal = unSignal(42);
+    const myComputed = unComputed(mySignal.get);
+
+    unEffect(() => {
+      myComputed.peek();
+      fn1Spy();
+    });
+
+    mySignal.set(100);
+    expect(myComputed.peek()).toBe(100);
+
+    expect(fn1Spy).toHaveBeenCalledTimes(1);
+  });
+
   describe('isUnComputed', () => {
     it('should return true for an UnComputed', () => {
       const myComputed = unComputed(() => 42);

packages/unuse-reactivity/src/unComputed/index.ts

@@ -3,6 +3,7 @@ import {
   checkDirty,
   link,
   REACTIVITY_STATE,
+  setCurrentSub,
   shallowPropagate,
   updateComputed,
 } from '../unReactiveSystem';
@@ -12,32 +13,6 @@ export interface UnComputedState<T> extends ReactiveNode {
   getter: (previousValue?: T) => T;
 }
 
-export function computedOper<T>(this: UnComputedState<T>): T {
-  const flags = this.flags;
-  if (
-    flags & (16 satisfies ReactiveFlags.Dirty) ||
-    (flags & (32 satisfies ReactiveFlags.Pending) &&
-      checkDirty(this.deps!, this))
-  ) {
-    if (updateComputed(this)) {
-      const subs = this.subs;
-      if (subs !== undefined) {
-        shallowPropagate(subs);
-      }
-    }
-  } else if (flags & (32 satisfies ReactiveFlags.Pending)) {
-    this.flags = flags & ~(32 satisfies ReactiveFlags.Pending);
-  }
-
-  if (REACTIVITY_STATE.activeSub !== undefined) {
-    link(this, REACTIVITY_STATE.activeSub);
-  } else if (REACTIVITY_STATE.activeScope !== undefined) {
-    link(this, REACTIVITY_STATE.activeScope);
-  }
-
-  return this.value!;
-}
-
 /**
  * A unique symbol used to identify `UnComputed` objects.
  *
@@ -59,6 +34,11 @@ export interface UnComputed<T> {
    * Retrieves the current value of the computed.
    */
   get(): T;
+
+  /**
+   * Retrieves the current value of the signal without triggering effects.
+   */
+  peek(): T;
 }
 
 /**
@@ -69,19 +49,49 @@ export interface UnComputed<T> {
  * @returns An `UnComputed` object that has a `get` method to retrieve the current value.
  */
 export function unComputed<T>(callback: () => T): UnComputed<T> {
-  const get: UnComputed<T>['get'] = computedOper.bind({
+  const state: UnComputedState<T> = {
     value: undefined,
     subs: undefined,
     subsTail: undefined,
     deps: undefined,
     depsTail: undefined,
     flags: 17 as ReactiveFlags.Mutable | ReactiveFlags.Dirty,
     getter: callback,
-  } satisfies UnComputedState<T>) as UnComputed<T>['get'];
+  };
 
   return {
     [UN_COMPUTED]: true,
-    get,
+    get() {
+      const flags = state.flags;
+      if (
+        flags & (16 satisfies ReactiveFlags.Dirty) ||
+        (flags & (32 satisfies ReactiveFlags.Pending) &&
+          checkDirty(state.deps!, state))
+      ) {
+        if (updateComputed(state)) {
+          const subs = state.subs;
+          if (subs !== undefined) {
+            shallowPropagate(subs);
+          }
+        }
+      } else if (flags & (32 satisfies ReactiveFlags.Pending)) {
+        state.flags = flags & ~(32 satisfies ReactiveFlags.Pending);
+      }
+
+      if (REACTIVITY_STATE.activeSub !== undefined) {
+        link(state, REACTIVITY_STATE.activeSub);
+      } else if (REACTIVITY_STATE.activeScope !== undefined) {
+        link(state, REACTIVITY_STATE.activeScope);
+      }
+
+      return state.value!;
+    },
+    peek() {
+      const prev = setCurrentSub(undefined);
+      const val = this.get();
+      setCurrentSub(prev);
+      return val;
+    },
   };
 }