feat: new find blocking chore implementation

Author: Varixo

packages/qwik/src/core/client/vnode-impl.ts

@@ -1,4 +1,5 @@
 import { VNodeFlags } from './types';
+import { Chore } from '../shared/scheduler';
 import { mapApp_findIndx, mapArray_get } from './util-mapArray';
 import {
   vnode_ensureElementInflated,
@@ -11,6 +12,8 @@ import {
 export abstract class VNode {
   props: (string | null | boolean)[] | null = null;
   slotParent: VNode | null = null;
+  chores: Set<Chore> | null = null;
+  blockedChores: Set<Chore> | null = null;
 
   getSlotParent(): VNode | null {
     return this.slotParent;

packages/qwik/src/core/shared/scheduler-rules.ts

@@ -1,19 +1,28 @@
-import { vnode_isDescendantOf, vnode_isVNode } from '../client/vnode';
+import {
+  vnode_getParentOrProjectionParent,
+  vnode_isDescendantOf,
+  vnode_isVNode,
+} from '../client/vnode';
 import { Task, TaskFlags } from '../use/use-task';
 import type { QRLInternal } from './qrl/qrl-class';
 import type { Chore } from './scheduler';
 import type { Container, HostElement } from './types';
 import { ChoreType } from './util-chore-type';
 import { ELEMENT_SEQ } from './utils/markers';
 import { isNumber } from './utils/types';
-import type { ClientContainer } from '../client/types';
+import type { VNode } from '../client/vnode-impl';
 
 type BlockingRule = {
   blockedType: ChoreType;
   blockingType: ChoreType;
   match: (blocked: Chore, blocking: Chore, container: Container) => boolean;
 };
 
+const enum ChoreSetType {
+  CHORES,
+  BLOCKED_CHORES,
+}
+
 /**
  * Rules for determining if a chore is blocked by another chore. Some chores can block other chores.
  * They cannot run until the blocking chore has completed.
@@ -120,19 +129,25 @@ function isSameQrl(a: QRLInternal<unknown>, b: QRLInternal<unknown>): boolean {
   return a.$symbol$ === b.$symbol$;
 }
 
-function findBlockingChoreInQueue(
-  chore: Chore,
-  choreQueue: Chore[],
-  container: Container
-): Chore | null {
-  for (const candidate of choreQueue) {
-    // everything after VISIBLE is not blocking. Visible task, task and resource should not block anything in this rule.
-    if (candidate.$type$ >= ChoreType.VISIBLE || candidate.$type$ === ChoreType.TASK) {
-      continue;
-    }
-    if (isDescendant(chore, candidate)) {
-      return candidate;
+function findAncestorBlockingChore(chore: Chore, type: ChoreSetType): Chore | null {
+  const host = chore.$host$;
+  if (!vnode_isVNode(host)) {
+    return null;
+  }
+  const isNormalQueue = type === ChoreSetType.CHORES;
+  // Walk up the ancestor tree and check the map
+  let current: VNode | null = host;
+  current = vnode_getParentOrProjectionParent(current);
+  while (current) {
+    const blockingChores = isNormalQueue ? current.chores : current.blockedChores;
+    if (blockingChores) {
+      for (const blockingChore of blockingChores) {
+        if (blockingChore.$type$ < ChoreType.VISIBLE && blockingChore.$type$ !== ChoreType.TASK) {
+          return blockingChore;
+        }
+      }
     }
+    current = vnode_getParentOrProjectionParent(current);
   }
   return null;
 }
@@ -144,18 +159,17 @@ export function findBlockingChore(
   runningChores: Set<Chore>,
   container: Container
 ): Chore | null {
-  const blockingChoreInChoreQueue = findBlockingChoreInQueue(chore, choreQueue, container);
+  const blockingChoreInChoreQueue = findAncestorBlockingChore(chore, ChoreSetType.CHORES);
   if (blockingChoreInChoreQueue) {
     return blockingChoreInChoreQueue;
   }
-  // const blockingChoreInBlockedChores = findBlockingChoreInQueue(
-  //   chore,
-  //   Array.from(blockedChores),
-  //   container
-  // );
-  // if (blockingChoreInBlockedChores) {
-  //   return blockingChoreInBlockedChores;
-  // }
+  const blockingChoreInBlockedChores = findAncestorBlockingChore(
+    chore,
+    ChoreSetType.BLOCKED_CHORES
+  );
+  if (blockingChoreInBlockedChores) {
+    return blockingChoreInBlockedChores;
+  }
 
   for (const rule of BLOCKING_RULES) {
     if (chore.$type$ !== rule.blockedType) {

packages/qwik/src/core/shared/scheduler.ts

@@ -460,6 +460,9 @@ This is often caused by modifying a signal in an already rendered component duri
             addBlockedChore(blockedChore, blockingChore, blockedChores);
           } else {
             blockedChores.delete(blockedChore);
+            if (vnode_isVNode(blockedChore.$host$)) {
+              blockedChore.$host$.blockedChores?.delete(blockedChore);
+            }
             sortedInsert(choreQueue, blockedChore, (container as DomContainer).rootVNode || null);
             blockedChoresScheduled = true;
           }
@@ -488,6 +491,9 @@ This is often caused by modifying a signal in an already rendered component duri
         ) {
           // skip deleted chore
           DEBUG && debugTrace('skip chore', chore, choreQueue, blockedChores);
+          if (vnode_isVNode(chore.$host$)) {
+            chore.$host$.chores?.delete(chore);
+          }
           continue;
         }
 
@@ -564,6 +570,9 @@ This is often caused by modifying a signal in an already rendered component duri
     chore.$state$ = ChoreState.DONE;
     chore.$returnValue$ = value;
     chore.$resolve$?.(value);
+    if (vnode_isVNode(chore.$host$)) {
+      chore.$host$.chores?.delete(chore);
+    }
     DEBUG && debugTrace('execute.DONE', chore, choreQueue, blockedChores);
   }
 
@@ -865,6 +874,9 @@ This is often caused by modifying a signal in an already rendered component duri
     if (idx < 0) {
       /// 2. Insert the chore into the queue.
       sortedArray.splice(~idx, 0, value);
+      if (vnode_isVNode(value.$host$)) {
+        (value.$host$.chores || (value.$host$.chores = new Set())).add(value);
+      }
       return value;
     }
 
@@ -904,6 +916,9 @@ export function addBlockedChore(
   blockingChore.$blockedChores$ ||= [];
   blockingChore.$blockedChores$.push(blockedChore);
   blockedChores.add(blockedChore);
+  if (vnode_isVNode(blockedChore.$host$)) {
+    (blockedChore.$host$.blockedChores ||= new Set()).add(blockedChore);
+  }
 }
 
 function choreTypeToName(type: ChoreType): string {