feat: Cache.updateValue with function

fix: Cache.updateValue with promise

.vscode/settings.json

@@ -1,5 +1,5 @@
 {
   "typescript.tsdk": "node_modules/typescript/lib",
-  "vitest.commandLine": "pnpm test --",
+  "vitest.commandLine": "node --expose-gc node_modules/vitest/vitest.mjs",
   "testing.automaticallyOpenPeekView": "never"
 }

src/core/cache.ts

@@ -85,8 +85,12 @@ export class Cache<T> extends Store<Promise<T>> {
     return promise;
   }
 
-  updateValue(value: MaybePromise<T>) {
-    this.set(PromiseWithState.resolve(value));
+  updateValue(value: MaybePromise<T> | ((value: T) => T)) {
+    if (value instanceof Function) {
+      this.set(this.get().then((v) => value(v)));
+    } else {
+      this.set(PromiseWithState.resolve(value));
+    }
   }
 
   updateError(error: unknown) {
@@ -154,7 +158,7 @@ export class Cache<T> extends Store<Promise<T>> {
   protected watchPromise() {
     this.subscribe(
       async (promise) => {
-        if (promise instanceof PromiseWithState) {
+        if (promise instanceof PromiseWithState && promise.state.status !== 'pending') {
           this.state.set((state) => ({
             ...promise.state,
             isStale: false,

src/core/store.ts

@@ -235,7 +235,7 @@ export class Store<T> extends Callable<any, any> {
 
           resolve(value);
           stopped = true;
-          clearTimeout(timer);
+          timer && clearTimeout(timer);
           setTimeout(() => cancel());
         },
         {

src/lib/isPromise.ts

@@ -0,0 +1,8 @@
+export default function isPromise(value: unknown): value is Promise<unknown> {
+  return (
+    typeof value === 'object' &&
+    value !== null &&
+    'then' in value &&
+    typeof value.then === 'function'
+  );
+}

src/lib/promiseWithState.ts

@@ -1,3 +1,4 @@
+import isPromise from '@lib/isPromise';
 import { type ErrorState, type PendingState, type ValueState } from './cacheState';
 import { type MaybePromise } from './maybePromise';
 
@@ -11,28 +12,29 @@ export class PromiseWithState<T> extends Promise<T> {
   static override resolve<T>(value: MaybePromise<T>): PromiseWithState<T>;
 
   static override resolve<T>(value?: MaybePromise<T>) {
-    return new PromiseWithState<T>(Promise.resolve(value as MaybePromise<T>), {
-      status: 'value',
-      value: value as T,
-    });
+    return new PromiseWithState<T>(value as MaybePromise<T>);
   }
 
   static override reject<T = never>(error: unknown) {
     return new PromiseWithState<T>(Promise.reject(error), { status: 'error', error });
   }
 
   constructor(
-    value: Promise<T>,
+    value: MaybePromise<T>,
     public state: ValueState<T> | ErrorState | PendingState = { status: 'pending' },
   ) {
     super((resolve) => resolve(value));
 
-    value
-      .then((value) => {
-        this.state = { status: 'value', value };
-      })
-      .catch((error) => {
-        this.state = { status: 'error', error };
-      });
+    if (isPromise(value)) {
+      value
+        .then((value) => {
+          this.state = { status: 'value', value: value };
+        })
+        .catch((error) => {
+          this.state = { status: 'error', error };
+        });
+    } else {
+      this.state = { status: 'value', value: value };
+    }
   }
 }

test/core/cache.test.ts

@@ -108,7 +108,7 @@ describe('cache', () => {
   });
 
   describe('update cache', () => {
-    test('update plain value', async () => {
+    test('with plain value', async () => {
       const cache = createCache(async () => 1);
       cache.updateValue(2);
 
@@ -120,6 +120,34 @@ describe('cache', () => {
         isConnected: false,
       });
     });
+
+    test('with promise', async () => {
+      const cache = createCache(async () => 1);
+      cache.updateValue(Promise.resolve(2));
+      await cache.get();
+
+      expect(cache.state.get()).toStrictEqual({
+        status: 'value',
+        value: 2,
+        isStale: false,
+        isUpdating: false,
+        isConnected: false,
+      });
+    });
+
+    test('with function', async () => {
+      const cache = createCache(async () => 1);
+      cache.updateValue((x) => x + 1);
+      await cache.get();
+
+      expect(cache.state.get()).toStrictEqual({
+        status: 'value',
+        value: 2,
+        isStale: false,
+        isUpdating: false,
+        isConnected: false,
+      });
+    });
   });
 
   describe('sub', () => {