Fix stale computed values (#300)

* Prevent stale computed values

* Remove atom levels

The previous commit's solution to the stale atom problem also solves the
diamond problem without needing special handling of atom levels.

* Optimize computed dependency check using epochs

* Update size-limit

---------

Co-authored-by: Andrey Sitnik <andrey@sitnik.ru>

atom/index.js

@@ -1,8 +1,9 @@
 import { clean } from '../clean-stores/index.js'
 
 let listenerQueue = []
+export let epoch = 0
 
-export let atom = (initialValue, level) => {
+export let atom = (initialValue) => {
   let listeners = []
   let $atom = {
     get() {
@@ -11,16 +12,15 @@ export let atom = (initialValue, level) => {
       }
       return $atom.value
     },
-    l: level || 0,
     lc: 0,
-    listen(listener, listenerLevel) {
-      $atom.lc = listeners.push(listener, listenerLevel || $atom.l) / 2
+    listen(listener) {
+      $atom.lc = listeners.push(listener)
 
       return () => {
         let index = listeners.indexOf(listener)
         let queueIndex = listenerQueue.indexOf(listener)
         if (~index) {
-          listeners.splice(index, 2)
+          listeners.splice(index, 1)
           if (!--$atom.lc) $atom.off()
         }
         if (~queueIndex) {
@@ -29,39 +29,24 @@ export let atom = (initialValue, level) => {
       }
     },
     notify(oldValue, changedKey) {
+      epoch++
       let runListenerQueue = !listenerQueue.length
-      for (let i = 0; i < listeners.length; i += 2) {
+      for (let listener of listeners) {
         listenerQueue.push(
-          listeners[i],
-          listeners[i + 1],
+          listener,
           $atom.value,
           oldValue,
           changedKey
         )
       }
 
       if (runListenerQueue) {
-        for (let i = 0; i < listenerQueue.length; i += 5) {
-          let skip
-          for (let j = i + 1; !skip && (j += 5) < listenerQueue.length; ) {
-            if (listenerQueue[j] < listenerQueue[i + 1]) {
-              skip = listenerQueue.push(
-                listenerQueue[i],
-                listenerQueue[i + 1],
-                listenerQueue[i + 2],
-                listenerQueue[i + 3],
-                listenerQueue[i + 4]
-              )
-            }
-          }
-
-          if (!skip) {
+        for (let i = 0; i < listenerQueue.length; i += 4) {
             listenerQueue[i](
+              listenerQueue[i + 1],
               listenerQueue[i + 2],
-              listenerQueue[i + 3],
-              listenerQueue[i + 4]
+              listenerQueue[i + 3]
             )
-          }
         }
         listenerQueue.length = 0
       }
@@ -76,8 +61,8 @@ export let atom = (initialValue, level) => {
         $atom.notify(oldValue)
       }
     },
-    subscribe(listener, listenerLevel) {
-      let unbind = $atom.listen(listener, listenerLevel)
+    subscribe(listener) {
+      let unbind = $atom.listen(listener)
       listener($atom.value)
       return unbind
     },

computed/index.js

@@ -1,12 +1,15 @@
-import { atom } from '../atom/index.js'
+import { atom, epoch } from '../atom/index.js'
 import { onMount } from '../lifecycle/index.js'
 
 let computedStore = (stores, cb, batched) => {
   if (!Array.isArray(stores)) stores = [stores]
 
   let previousArgs
   let currentRunId = 0
+  let currentEpoch
   let set = () => {
+    if (currentEpoch === epoch) return
+    currentEpoch = epoch
     let args = stores.map($store => $store.get())
     if (
       previousArgs === undefined ||
@@ -27,7 +30,12 @@ let computedStore = (stores, cb, batched) => {
       }
     }
   }
-  let $computed = atom(undefined, Math.max(...stores.map($s => $s.l)) + 1)
+  let $computed = atom(undefined)
+  let get = $computed.get
+  $computed.get = () => {
+    set()
+    return get()
+  }
 
   let timer
   let run = batched
@@ -38,7 +46,7 @@ let computedStore = (stores, cb, batched) => {
     : set
 
   onMount($computed, () => {
-    let unbinds = stores.map($store => $store.listen(run, -1 / $computed.l))
+    let unbinds = stores.map($store => $store.listen(run))
     set()
     return () => {
       for (let unbind of unbinds) unbind()

computed/index.test.ts

@@ -547,3 +547,42 @@ test('cleans up on unmount', async () => {
   equal($derived.lc, 0)
   equal($source.lc, 0)
 })
+
+test('stale computed in other computed', () => {
+  let $atom = atom(1)
+  let values: (number | string)[] = []
+  let $computed1 = computed($atom, () => {values.push($computed2.get())})
+  let $computed2 = computed($atom, value => value * 2)
+  $computed1.subscribe(() => {})
+  $atom.set(2)
+  deepStrictEqual(values, [2, 4])
+})
+
+test('stale computed in listener', () => {
+  let $event = atom()
+  let $atom = atom(1)
+  let $computed = computed($atom, value => value * 2)
+  $computed.listen(() => {})
+  let values: (number | string)[] = []
+  $event.listen(() => {
+    $atom.set(2)
+    values.push($computed.get())
+  })
+  $event.set("foo")
+  deepStrictEqual(values, [4])
+})
+
+test('stale computed via nested dependency', () => {
+  let $event = atom()
+  let $atom = atom(1)
+  let $computed1 = computed($atom, value => value * 2)
+  let $computed2 = computed($computed1, value => value * 3)
+  $computed2.listen(() => {})
+  let values: (number | string)[] = []
+  $event.listen(() => {
+    $atom.set(2)
+    values.push($computed2.get())
+  })
+  $event.set("foo")
+  deepStrictEqual(values, [12])
+})

package.json

@@ -92,14 +92,14 @@
       "import": {
         "./index.js": "{ atom }"
       },
-      "limit": "302 B"
+      "limit": "235 B"
     },
     {
       "name": "Popular Set",
       "import": {
         "./index.js": "{ map, computed, }"
       },
-      "limit": "831 B"
+      "limit": "769 B"
     }
   ],
   "clean-publish": {