tmp-revert

Author: johnsoncodehk

packages/reactivity/src/system.ts

@@ -258,68 +258,87 @@ function linkNewDep(
   return newLink
 }
 
-function checkDirty(current: Link): boolean {
-  let prevLinks: OneWayLink<Link> | undefined
-  let checkDepth = 0
+function checkDirty(link: Link): boolean {
+  let stack = 0
+  let dirty: boolean
 
   top: do {
-    const dep = current.dep
+    dirty = false
+    const dep = link.dep
 
     if ('flags' in dep) {
       const depFlags = dep.flags
       if (
         (depFlags & (SubscriberFlags.Computed | SubscriberFlags.Dirty)) ===
         (SubscriberFlags.Computed | SubscriberFlags.Dirty)
       ) {
-        if (dep.update()) {
-          if (current.nextSub !== undefined || current.prevSub !== undefined) {
-            shallowPropagate(dep.subs!)
+        if ((dep as Computed).update()) {
+          const subs = dep.subs!
+          if (subs.nextSub !== undefined) {
+            shallowPropagate(subs)
           }
-          while (checkDepth--) {
-            const computed = current.sub as Computed
-            const firstSub = computed.subs!
-
-            if (computed.update()) {
-              if (firstSub.nextSub !== undefined) {
-                shallowPropagate(firstSub)
-                current = prevLinks!.target
-                prevLinks = prevLinks!.linked
-              } else {
-                current = firstSub
-              }
-              continue
-            }
-
-            if (firstSub.nextSub !== undefined) {
-              if ((current = prevLinks!.target.nextDep!) === undefined) {
-                return false
-              }
-              prevLinks = prevLinks!.linked
-              continue top
-            }
-
-            return false
-          }
-          return true
+          dirty = true
         }
       } else if (
         (depFlags &
           (SubscriberFlags.Computed | SubscriberFlags.PendingComputed)) ===
         (SubscriberFlags.Computed | SubscriberFlags.PendingComputed)
       ) {
-        dep.flags = depFlags & ~SubscriberFlags.PendingComputed
-        if (current.nextSub !== undefined || current.prevSub !== undefined) {
-          prevLinks = { target: current, linked: prevLinks }
+        const depSubs = dep.subs!
+        if (depSubs.nextSub !== undefined) {
+          depSubs.prevSub = link
         }
-        ++checkDepth
-        current = dep.deps!
+        link = dep.deps!
+        ++stack
         continue
       }
     }
 
-    if ((current = current.nextDep!) === undefined) {
-      return false
+    if (!dirty && link.nextDep !== undefined) {
+      link = link.nextDep
+      continue
+    }
+
+    if (stack) {
+      let sub = link.sub as Computed
+      do {
+        --stack
+        const subSubs = sub.subs!
+
+        if (dirty) {
+          if (sub.update()) {
+            if ((link = subSubs.prevSub!) !== undefined) {
+              subSubs.prevSub = undefined
+              shallowPropagate(subSubs)
+              sub = link.sub as Computed
+            } else {
+              sub = subSubs.sub as Computed
+            }
+            continue
+          }
+        } else {
+          sub.flags &= ~SubscriberFlags.PendingComputed
+        }
+
+        if ((link = subSubs.prevSub!) !== undefined) {
+          subSubs.prevSub = undefined
+          if (link.nextDep !== undefined) {
+            link = link.nextDep
+            continue top
+          }
+          sub = link.sub as Computed
+        } else {
+          if ((link = subSubs.nextDep!) !== undefined) {
+            continue top
+          }
+          sub = subSubs.sub as Computed
+        }
+
+        dirty = false
+      } while (stack)
     }
+
+    return dirty
   } while (true)
 }