@furystack/utils 8.1.9 → 8.2.0

package/src/observable-value.spec.ts

@@ -1,58 +1,65 @@
 import { describe, expect, it, vi } from 'vitest'
 import { ObservableValue } from './observable-value.js'
+import { sleepAsync } from './sleep-async.js'
+import { using } from './using.js'
 
 /**
  * Observable Value tests
  */
 export const observableTests = describe('Observable', () => {
   it('should be constructed with an undefined initial value', () => {
-    const v = new ObservableValue(undefined)
-    expect(v).toBeInstanceOf(ObservableValue)
-    expect(v.getValue()).toBe(undefined)
+    using(new ObservableValue(undefined), (v) => {
+      expect(v).toBeInstanceOf(ObservableValue)
+      expect(v.getValue()).toBe(undefined)
+    })
   })
 
   it('should be constructed with initial value', () => {
-    const v = new ObservableValue(1)
-    expect(v.getValue()).toBe(1)
+    using(new ObservableValue(1), (v) => {
+      expect(v.getValue()).toBe(1)
+    })
   })
 
   describe('Subscription callback', () => {
     it('should be triggered only when a value is changed', () => {
-      const v = new ObservableValue(1)
-      const doneCallback = vi.fn()
+      using(new ObservableValue(1), (v) => {
+        const doneCallback = vi.fn()
 
-      v.subscribe(() => {
-        expect(v.getValue()).toBe(2)
-        doneCallback()
+        v.subscribe(() => {
+          expect(v.getValue()).toBe(2)
+          doneCallback()
+        })
+        v.setValue(1)
+        v.setValue(1)
+        v.setValue(2)
+        expect(doneCallback).toBeCalledTimes(1)
       })
-      v.setValue(1)
-      v.setValue(1)
-      v.setValue(2)
-      expect(doneCallback).toBeCalledTimes(1)
     })
 
     it('should be triggered only on change', () => {
-      const v = new ObservableValue(1)
-      const doneCallback = vi.fn()
+      using(new ObservableValue(1), (v) => {
+        const doneCallback = vi.fn()
 
-      v.subscribe((value) => {
-        expect(value).toBe(2)
-        doneCallback()
+        v.subscribe((value) => {
+          expect(value).toBe(2)
+          doneCallback()
+        })
+        v.setValue(2)
+        expect(doneCallback).toBeCalledTimes(1)
       })
-      v.setValue(2)
-      expect(doneCallback).toBeCalledTimes(1)
     })
 
     it('should be triggered only on change in async manner', () => {
-      const v = new ObservableValue(1)
-      const doneCallback = vi.fn()
+      using(new ObservableValue(1), (v) => {
+        const doneCallback = vi.fn()
 
-      v.subscribe(async (value) => {
-        expect(value).toBe(2)
-        doneCallback()
+        v.subscribe(async (value) => {
+          expect(value).toBe(2)
+          doneCallback()
+        })
+        v.setValue(2)
+        expect(doneCallback).toBeCalledTimes(1)
       })
-      v.setValue(2)
-      expect(doneCallback).toBeCalledTimes(1)
     })
   })
 
@@ -64,15 +71,16 @@ export const observableTests = describe('Observable', () => {
         expect(value).toBe(2)
       })
 
-      const v = new ObservableValue(1)
-      const observer1 = v.subscribe(shouldNotCall)
-      v.subscribe(doneCallback)
+      using(new ObservableValue(1), (v) => {
+        const observer1 = v.subscribe(shouldNotCall)
+        v.subscribe(doneCallback)
 
-      v.unsubscribe(observer1)
-      v.setValue(2)
+        v.unsubscribe(observer1)
+        v.setValue(2)
 
-      expect(doneCallback).toBeCalledTimes(1)
-      expect(shouldNotCall).not.toBeCalled()
+        expect(doneCallback).toBeCalledTimes(1)
+        expect(shouldNotCall).not.toBeCalled()
+      })
     })
 
     it('should remove the subscription on Observable dispose', () => {
@@ -93,14 +101,15 @@ export const observableTests = describe('Observable', () => {
     })
 
     it('should remove the subscription on Observer dispose', () => {
-      const callback1 = () => {
-        /** */
-      }
-      const v = new ObservableValue(1)
-      const observer = v.subscribe(callback1)
-      expect(v.getObservers().length).toBe(1)
-      observer[Symbol.dispose]()
-      expect(v.getObservers().length).toBe(0)
+      using(new ObservableValue(1), (v) => {
+        const callback1 = () => {
+          /** */
+        }
+        const observer = v.subscribe(callback1)
+        expect(v.getObservers().length).toBe(1)
+        observer[Symbol.dispose]()
+        expect(v.getObservers().length).toBe(0)
+      })
     })
 
     it('should throw an error for setValue() when the observer has been disposed', () => {
@@ -133,62 +142,169 @@ export const observableTests = describe('Observable', () => {
           doneCallback()
         }
       }
-      const v = new ObservableValue(1)
-      const observer = v.subscribe(() => new Alma().Callback())
-      v.subscribe(() => new Alma().Callback())
-      expect(v.getObservers().length).toBe(2)
-      observer[Symbol.dispose]()
-      expect(v.getObservers().length).toBe(1)
-      v.setValue(3)
+      using(new ObservableValue(1), (v) => {
+        const observer = v.subscribe(() => new Alma().Callback())
+        v.subscribe(() => new Alma().Callback())
+        expect(v.getObservers().length).toBe(2)
+        observer[Symbol.dispose]()
+        expect(v.getObservers().length).toBe(1)
+        v.setValue(3)
 
-      expect(doneCallback).toBeCalledTimes(1)
+        expect(doneCallback).toBeCalledTimes(1)
+      })
     })
   })
 
   describe('Custom Compare function', () => {
     it('Should compare the values with the custom compare function', () => {
-      const v = new ObservableValue(
-        { value: 2 },
-        {
-          compare: (a, b) => a.value !== b.value,
-        },
-      )
-      const onChange = vi.fn()
-      v.subscribe(onChange)
+      using(
+        new ObservableValue(
+          { value: 2 },
+          {
+            compare: (a, b) => a.value !== b.value,
+          },
+        ),
+        (v) => {
+          const onChange = vi.fn()
+          v.subscribe(onChange)
 
-      v.setValue({ value: 2 })
-      expect(v.getValue()).toEqual({ value: 2 })
-      expect(onChange).not.toBeCalled()
+          v.setValue({ value: 2 })
+          expect(v.getValue()).toEqual({ value: 2 })
+          expect(onChange).not.toBeCalled()
 
-      v.setValue({ value: 3 })
-      expect(v.getValue()).toEqual({ value: 3 })
-      expect(onChange).toBeCalledTimes(1)
-      expect(onChange).toBeCalledWith({ value: 3 })
+          v.setValue({ value: 3 })
+          expect(v.getValue()).toEqual({ value: 3 })
+          expect(onChange).toBeCalledTimes(1)
+          expect(onChange).toBeCalledWith({ value: 3 })
 
-      v.setValue({ value: 3 })
-      expect(v.getValue()).toEqual({ value: 3 })
-      expect(onChange).toBeCalledTimes(1)
+          v.setValue({ value: 3 })
+          expect(v.getValue()).toEqual({ value: 3 })
+          expect(onChange).toBeCalledTimes(1)
+        },
+      )
     })
   })
 
   describe('Filtered subscriptions', () => {
     it('should not trigger the callback if the filter returns false', () => {
-      const v = new ObservableValue({ shouldNotify: true, value: 1 })
-      const onChange = vi.fn()
-      v.subscribe(onChange, {
-        filter: (nextValue) => nextValue.shouldNotify,
+      using(new ObservableValue({ shouldNotify: true, value: 1 }), (v) => {
+        const onChange = vi.fn()
+        v.subscribe(onChange, {
+          filter: (nextValue) => nextValue.shouldNotify,
+        })
+
+        v.setValue({ shouldNotify: false, value: 1 })
+        expect(onChange).not.toBeCalled()
+
+        v.setValue({ shouldNotify: false, value: 2 })
+        expect(onChange).not.toBeCalled()
+        expect(v.getValue()).toEqual({ shouldNotify: false, value: 2 })
+
+        v.setValue({ shouldNotify: true, value: 3 })
+        expect(onChange).toBeCalledTimes(1)
+        expect(onChange).toBeCalledWith({ shouldNotify: true, value: 3 })
       })
+    })
+  })
 
-      v.setValue({ shouldNotify: false, value: 1 })
-      expect(onChange).not.toBeCalled()
+  describe('Observer error handling', () => {
+    it('should catch sync throws from observer callbacks and still notify other observers', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
 
-      v.setValue({ shouldNotify: false, value: 2 })
-      expect(onChange).not.toBeCalled()
-      expect(v.getValue()).toEqual({ shouldNotify: false, value: 2 })
+      using(new ObservableValue(0), (v) => {
+        const goodCallback = vi.fn()
+
+        v.subscribe(() => {
+          throw new Error('observer error')
+        })
+        v.subscribe(goodCallback)
+
+        v.setValue(1)
+
+        expect(goodCallback).toBeCalledWith(1)
+        expect(goodCallback).toBeCalledTimes(1)
+        expect(consoleErrorSpy).toHaveBeenCalled()
+      })
+
+      consoleErrorSpy.mockRestore()
+    })
+
+    it('should catch async rejections from observer callbacks', async () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+      using(new ObservableValue(0), (v) => {
+        v.subscribe(async () => {
+          throw new Error('async observer error')
+        })
+
+        v.setValue(1)
+      })
+
+      await sleepAsync(10)
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('Error in ObservableValue observer', expect.any(Error))
+
+      consoleErrorSpy.mockRestore()
+    })
+
+    it('should catch errors thrown by filter functions', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+      using(new ObservableValue(0), (v) => {
+        const goodCallback = vi.fn()
+
+        v.subscribe(
+          () => {
+            /* never reached */
+          },
+          {
+            filter: () => {
+              throw new Error('filter error')
+            },
+          },
+        )
+        v.subscribe(goodCallback)
+
+        v.setValue(1)
+
+        expect(goodCallback).toBeCalledWith(1)
+        expect(consoleErrorSpy).toHaveBeenCalled()
+      })
+
+      consoleErrorSpy.mockRestore()
+    })
+
+    it('should use custom onError callback when provided', () => {
+      const onError = vi.fn()
+
+      using(new ObservableValue(0, { onError }), (v) => {
+        v.subscribe(() => {
+          throw new Error('custom error')
+        })
+
+        v.setValue(1)
+
+        expect(onError).toBeCalledTimes(1)
+        expect(onError).toBeCalledWith({
+          error: expect.any(Error) as Error,
+          observer: expect.objectContaining({ callback: expect.any(Function) as () => void }) as object,
+        })
+      })
+    })
+
+    it('should update the value even when observers throw', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {})
+
+      using(new ObservableValue(0), (v) => {
+        v.subscribe(() => {
+          throw new Error('error')
+        })
+
+        v.setValue(42)
+        expect(v.getValue()).toBe(42)
+      })
 
-      v.setValue({ shouldNotify: true, value: 3 })
-      expect(onChange).toBeCalledTimes(1)
-      expect(onChange).toBeCalledWith({ shouldNotify: true, value: 3 })
+      consoleErrorSpy.mockRestore()
     })
   })
 })

package/src/observable-value.ts

@@ -23,6 +23,12 @@ export type ObservableValueOptions<T> = {
    * @returns whether the value should be updated and the observers should be notified
    */
   compare: (lastValue: T, nextValue: T) => boolean
+  /**
+   * Called when an observer callback or filter throws (sync) or rejects (async).
+   * All remaining observers are still notified even when one fails.
+   * Defaults to logging the error via `console.error`.
+   */
+  onError: (options: { error: unknown; observer: ValueObserver<T> }) => void
 }
 
 const defaultComparer = <T>(a: T, b: T) => a !== b
@@ -112,8 +118,17 @@ export class ObservableValue<T> implements Disposable {
     if (this.options.compare(this.currentValue, newValue)) {
       this.currentValue = newValue
       this.observers.forEach((observer) => {
-        if (observer.options?.filter?.(this.currentValue, newValue) !== false) {
-          observer.callback(newValue)
+        try {
+          if (observer.options?.filter?.(this.currentValue, newValue) !== false) {
+            const result = observer.callback(newValue)
+            if (result && typeof result.then === 'function') {
+              result.then(undefined, (error: unknown) => {
+                this.options.onError({ error, observer })
+              })
+            }
+          }
+        } catch (error) {
+          this.options.onError({ error, observer })
         }
       })
     }
@@ -136,6 +151,7 @@ export class ObservableValue<T> implements Disposable {
   constructor(initialValue: T, options?: Partial<ObservableValueOptions<T>>) {
     this.options = {
       compare: defaultComparer,
+      onError: ({ error }) => console.error('Error in ObservableValue observer', error),
       ...options,
     }
     this.currentValue = initialValue