fix(store): run compare when the previous atom value is undefined

.changeset/atom-compare-undefined.md

@@ -0,0 +1,5 @@
+---
+'@tanstack/store': patch
+---
+
+Fix atoms skipping `compare` whenever their previous value was `undefined`. A computed atom that keeps returning `undefined` no longer notifies its subscribers on every recompute, and a custom `compare` now decides updates from an `undefined` value too. A computed atom's first computation still skips `compare`.

packages/store/src/atom.ts

@@ -157,6 +157,7 @@ export function createAtom<T>(
 ): Atom<T> | ReadonlyAtom<T> {
   const isComputed = typeof valueOrFn === 'function'
   const getter = valueOrFn as (prev?: T) => T
+  let isFirstComputation = isComputed
 
   // Create plain object atom
   const atom: InternalAtom<T> = {
@@ -219,7 +220,8 @@ export function createAtom<T>(
             : getValue === undefined && isComputed
               ? getter(oldValue)
               : getValue!
-        if (oldValue === undefined || !compare(oldValue, newValue)) {
+        if (isFirstComputation || !compare(oldValue, newValue)) {
+          isFirstComputation = false
           atom._snapshot = newValue
           return true
         }

packages/store/tests/undefined-snapshot.test.ts

@@ -0,0 +1,42 @@
+import { describe, expect, test, vi } from 'vitest'
+import { createAtom } from '../src'
+
+describe('undefined snapshots', () => {
+  test('a computed atom that stays undefined does not notify', () => {
+    const source = createAtom(0)
+    const derived = createAtom(() =>
+      source.get() > 10 ? source.get() : undefined,
+    )
+    const fn = vi.fn()
+    derived.subscribe(fn)
+
+    source.set(1)
+    source.set(2)
+
+    expect(fn).not.toHaveBeenCalled()
+  })
+
+  test('compare still decides when the previous value is undefined', () => {
+    const atom = createAtom<number | undefined>(undefined, {
+      compare: () => true,
+    })
+    const fn = vi.fn()
+    atom.subscribe(fn)
+
+    atom.set(1)
+
+    expect(atom.get()).toBeUndefined()
+    expect(fn).not.toHaveBeenCalled()
+  })
+
+  test('compare is not called before a computed atom first computes', () => {
+    const source = createAtom(0)
+    const compare = vi.fn(
+      (prev: Array<number>, next: Array<number>) => prev.length === next.length,
+    )
+    const derived = createAtom(() => [source.get()], { compare })
+
+    expect(derived.get()).toEqual([0])
+    expect(compare).not.toHaveBeenCalled()
+  })
+})