@qwik.dev/core 2.0.0-beta.13 → 2.0.0-beta.14

package/dist/testing/index.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core/testing 2.0.0-beta.13-dev+cb19ff7
+ * @qwik.dev/core/testing 2.0.0-beta.14-dev+1e7496d
  * Copyright QwikDev. All Rights Reserved.
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://github.com/QwikDev/qwik/blob/main/LICENSE
@@ -24161,21 +24161,14 @@ var PropsProxyHandler = class {
         }
       }
       if (this.owner.constProps && prop in this.owner.constProps) {
-        this.owner.constProps[prop] = void 0;
-        if (!(prop in this.owner.varProps)) {
-          this.owner.toSort = true;
-        }
-        this.owner.varProps[prop] = value;
-      } else {
-        if (this.owner.varProps === EMPTY_OBJ) {
-          this.owner.varProps = {};
-        } else {
-          if (!(prop in this.owner.varProps)) {
-            this.owner.toSort = true;
-          }
-        }
-        this.owner.varProps[prop] = value;
+        delete this.owner.constProps[prop];
+      }
+      if (this.owner.varProps === EMPTY_OBJ) {
+        this.owner.varProps = {};
+      } else if (!(prop in this.owner.varProps)) {
+        this.owner.toSort = true;
       }
+      this.owner.varProps[prop] = value;
     }
     return true;
   }
@@ -24234,6 +24227,19 @@ var isPropsProxy = (obj) => {
   return obj && _VAR_PROPS in obj;
 };
 
+// packages/qwik/src/core/use/utils/destroyable.ts
+var cleanupDestroyable = (destroyable) => {
+  const destroy = destroyable.$destroy$;
+  if (destroy) {
+    destroyable.$destroy$ = null;
+    try {
+      destroy();
+    } catch (err) {
+      logError(err);
+    }
+  }
+};
+
 // packages/qwik/src/core/reactive-primitives/subscriber.ts
 import { isServer as isServer3 } from "@qwik.dev/core/build";
 function getSubscriber(effect, prop, data) {
@@ -24293,13 +24299,13 @@ var cleanupFn = (target, handleError) => {
         cleanupFns = [];
         target.$destroy$ = noSerialize(() => {
           target.$destroy$ = null;
-          cleanupFns.forEach((fn2) => {
+          for (const fn2 of cleanupFns) {
             try {
               fn2();
             } catch (err) {
               handleError(err);
             }
-          });
+          }
         });
       }
       cleanupFns.push(fn);
@@ -24505,6 +24511,7 @@ var AsyncComputedSignalImpl = class extends (_b2 = ComputedSignalImpl, _a2 = _EF
     __publicField(this, "$errorEffects$", null);
     __publicField(this, "$destroy$");
     __publicField(this, "$promiseValue$", NEEDS_COMPUTATION);
+    __publicField(this, "$promise$", null);
     __publicField(this, _a2, null);
   }
   /**
@@ -24556,9 +24563,10 @@ var AsyncComputedSignalImpl = class extends (_b2 = ComputedSignalImpl, _a2 = _EF
   }
   invalidate() {
     super.invalidate();
-    this.$promiseValue$ = NEEDS_COMPUTATION;
+    this.$promise$ = null;
   }
-  async resolve() {
+  async promise() {
+    this.$promise$ = null;
     await retryOnPromise(() => this.$computeIfNeeded$());
     return this.$untrackedValue$;
   }
@@ -24566,31 +24574,62 @@ var AsyncComputedSignalImpl = class extends (_b2 = ComputedSignalImpl, _a2 = _EF
     if (!(this.$flags$ & 1 /* INVALID */)) {
       return;
     }
-    const [cleanup2] = cleanupFn(this, (err) => this.$container$?.handleError(err, null));
-    const untrackedValue = this.$promiseValue$ === NEEDS_COMPUTATION ? this.$computeQrl$.getFn()({
-      track: trackFn(this, this.$container$),
-      cleanup: cleanup2
-    }) : this.$promiseValue$;
+    const untrackedValue = (
+      // first time
+      this.$promiseValue$ === NEEDS_COMPUTATION || // or after invalidation
+      this.$promise$ === null ? this.$promiseComputation$() : this.$promiseValue$
+    );
     if (isPromise(untrackedValue)) {
+      const isFirstComputation = this.$promiseValue$ === NEEDS_COMPUTATION;
       this.untrackedLoading = true;
       this.untrackedError = null;
-      throw untrackedValue.then((promiseValue) => {
+      if (this.$promiseValue$ !== NEEDS_COMPUTATION) {
+        cleanupDestroyable(this);
+      }
+      const promise = untrackedValue.then((promiseValue) => {
+        DEBUG3 && log3("Promise resolved", promiseValue);
         this.$promiseValue$ = promiseValue;
         this.untrackedLoading = false;
         this.untrackedError = null;
+        if (this.setValue(promiseValue)) {
+          DEBUG3 && log3("Scheduling effects for subscribers", this.$effects$?.size);
+          scheduleEffects(this.$container$, this, this.$effects$);
+        }
       }).catch((err) => {
+        if (isPromise(err)) {
+          return;
+        }
+        DEBUG3 && log3("Error caught in promise.catch", err);
         this.$promiseValue$ = err;
         this.untrackedLoading = false;
         this.untrackedError = err;
       });
+      if (isFirstComputation) {
+        throw promise;
+      } else {
+        DEBUG3 && log3("Returning stale value", this.$untrackedValue$, "while computing", untrackedValue);
+        return promise;
+      }
+    } else {
+      this.setValue(untrackedValue);
+    }
+  }
+  async $promiseComputation$() {
+    if (!this.$promise$) {
+      const [cleanup2] = cleanupFn(this, (err) => this.$container$?.handleError(err, null));
+      this.$promise$ = this.$computeQrl$.getFn()({
+        track: trackFn(this, this.$container$),
+        cleanup: cleanup2
+      });
     }
-    this.$promiseValue$ = NEEDS_COMPUTATION;
-    DEBUG3 && log3("Signal.$asyncCompute$", untrackedValue);
+    return this.$promise$;
+  }
+  setValue(value) {
     this.$flags$ &= ~1 /* INVALID */;
-    const didChange = untrackedValue !== this.$untrackedValue$;
+    const didChange = value !== this.$untrackedValue$;
     if (didChange) {
+      this.$untrackedValue$ = value;
       this.$flags$ |= 2 /* RUN_EFFECTS */;
-      this.$untrackedValue$ = untrackedValue;
     }
     return didChange;
   }
@@ -25414,9 +25453,12 @@ function clearAsyncComputedSignal(producer, effect) {
 function clearStore(producer, effect) {
   const effects = producer?.$effects$;
   if (effects) {
-    for (const propEffects of effects.values()) {
+    for (const [propKey, propEffects] of effects.entries()) {
       if (propEffects.has(effect)) {
         propEffects.delete(effect);
+        if (propEffects.size === 0) {
+          effects.delete(propKey);
+        }
       }
     }
   }
@@ -25479,7 +25521,7 @@ var useSequentialScope = () => {
 // packages/qwik/src/core/use/use-task.ts
 var runTask = (task, container, host) => {
   task.$flags$ &= ~8 /* DIRTY */;
-  cleanupTask(task);
+  cleanupDestroyable(task);
   const iCtx = newInvokeContext(container.$locale$, host, void 0, TaskEvent);
   iCtx.$container$ = container;
   const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
@@ -25498,17 +25540,6 @@ var runTask = (task, container, host) => {
     }
   );
 };
-var cleanupTask = (task) => {
-  const destroy = task.$destroy$;
-  if (destroy) {
-    task.$destroy$ = null;
-    try {
-      destroy();
-    } catch (err) {
-      logError(err);
-    }
-  }
-};
 var Task = class extends BackRef {
   constructor($flags$, $index$, $el$, $qrl$, $state$, $destroy$) {
     super();
@@ -26369,6 +26400,7 @@ var vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
   let journal = container.$journal$;
   const stack2 = [];
   const asyncQueue = [];
+  const asyncAttributePromises = [];
   let vParent = null;
   let vCurrent = null;
   let vNewNode = null;
@@ -26708,6 +26740,12 @@ var vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
         diff(jsxNode2, vHostNode);
       }
     }
+    if (asyncAttributePromises.length) {
+      const promises = asyncAttributePromises.splice(0);
+      return Promise.all(promises).then(() => {
+        return drainAsyncQueue();
+      });
+    }
   }
   function expectNoChildren() {
     const vFirstChild = vCurrent && vnode_getFirstChild(vCurrent);
@@ -26749,11 +26787,11 @@ var vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
         if (vHost.flags & 64 /* NS_svg */) {
           const namespace = getAttributeNamespace(key2);
           if (namespace) {
-            element.setAttributeNS(namespace, key2, String(value));
+            element.setAttributeNS(namespace, key2, value);
             return;
           }
         }
-        element.setAttribute(key2, String(value));
+        element.setAttribute(key2, value);
       }
     }
     const { constProps } = jsx2;
@@ -26799,7 +26837,10 @@ var vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
         }
         if (isPromise(value)) {
           const vHost = vNewNode;
-          value.then((resolvedValue) => setAttribute(key2, resolvedValue, vHost));
+          const attributePromise = value.then(
+            (resolvedValue) => setAttribute(key2, resolvedValue, vHost)
+          );
+          asyncAttributePromises.push(attributePromise);
           continue;
         }
         if (key2 === dangerouslySetInnerHTML) {
@@ -26972,7 +27013,10 @@ var vnode_diff = (container, jsxNode, vStartNode, scopedStyleIdPrefix) => {
       }
       if (isPromise(value)) {
         const vHost = vnode;
-        value.then((resolvedValue) => setAttribute(key, resolvedValue, vHost));
+        const attributePromise = value.then(
+          (resolvedValue) => setAttribute(key, resolvedValue, vHost)
+        );
+        asyncAttributePromises.push(attributePromise);
         return;
       }
       setAttribute(key, value, vnode);
@@ -27409,25 +27453,26 @@ function cleanup(container, vNode) {
     if (type & 3 /* ELEMENT_OR_VIRTUAL_MASK */) {
       clearAllEffects(container, vCursor);
       markVNodeAsDeleted(vCursor);
-      if (type & 2 /* Virtual */) {
+      const isComponent = type & 2 /* Virtual */ && vCursor.getProp(OnRenderProp, null) !== null;
+      if (isComponent) {
         const seq = container.getHostProp(vCursor, ELEMENT_SEQ);
         if (seq) {
           for (let i = 0; i < seq.length; i++) {
             const obj = seq[i];
-            if (isTask(obj)) {
-              const task = obj;
-              clearAllEffects(container, task);
-              if (task.$flags$ & 1 /* VISIBLE_TASK */) {
-                container.$scheduler$(32 /* CLEANUP_VISIBLE */, task);
-              } else {
-                cleanupTask(task);
+            if (isObject(obj)) {
+              const objIsTask = isTask(obj);
+              if (objIsTask && obj.$flags$ & 1 /* VISIBLE_TASK */) {
+                container.$scheduler$(32 /* CLEANUP_VISIBLE */, obj);
+                continue;
+              } else if (obj instanceof SignalImpl || isStore(obj)) {
+                clearAllEffects(container, obj);
+              }
+              if (objIsTask || obj instanceof AsyncComputedSignalImpl) {
+                cleanupDestroyable(obj);
               }
             }
           }
         }
-      }
-      const isComponent = type & 2 /* Virtual */ && vCursor.getProp(OnRenderProp, null) !== null;
-      if (isComponent) {
         const attrs = vnode_getProps(vCursor);
         for (let i = 0; i < attrs.length; i = i + 2) {
           const key = attrs[i];
@@ -27528,7 +27573,7 @@ var createResourceReturn = (container, opts, initialPromise) => {
 };
 var runResource = (task, container, host) => {
   task.$flags$ &= ~8 /* DIRTY */;
-  cleanupTask(task);
+  cleanupDestroyable(task);
   const iCtx = newInvokeContext(container.$locale$, host, void 0, ResourceEvent);
   iCtx.$container$ = container;
   const taskFn = task.$qrl$.getFn(iCtx, () => clearAllEffects(container, task));
@@ -27618,7 +27663,7 @@ var runResource = (task, container, host) => {
       promise,
       delay(timeout).then(() => {
         if (setState(false, new Error("timeout"))) {
-          cleanupTask(task);
+          cleanupDestroyable(task);
         }
       })
     ]);
@@ -28003,6 +28048,8 @@ var createScheduler = (container, journalFlush, choreQueue, blockedChores, runni
   let currentTime = performance.now();
   const nextTick = createNextTick(drainChoreQueue);
   let flushTimerId = null;
+  let blockingChoresCount = 0;
+  let currentChore = null;
   function drainInNextTick() {
     if (!drainScheduled) {
       drainScheduled = true;
@@ -28073,6 +28120,9 @@ Problematic chore:
 This is often caused by modifying a signal in an already rendered component during SSR.`;
           logWarn(warningMessage);
           DEBUG6 && debugTrace("schedule.SKIPPED host is not updatable", chore, choreQueue, blockedChores);
+          if (isRenderBlocking(type)) {
+            blockingChoresCount--;
+          }
           return chore;
         }
       }
@@ -28096,8 +28146,13 @@ This is often caused by modifying a signal in an already rendered component duri
         return chore;
       }
     }
-    addChore(chore, choreQueue);
-    DEBUG6 && debugTrace("schedule", chore, choreQueue, blockedChores);
+    addChoreAndIncrementBlockingCounter(chore, choreQueue);
+    DEBUG6 && debugTrace(
+      isRenderBlocking(type) ? `schedule (blocking ${blockingChoresCount})` : "schedule",
+      chore,
+      choreQueue,
+      blockedChores
+    );
     const runImmediately = isServer6 && type === 6 /* COMPONENT */ || type === 2 /* RUN_QRL */;
     if (runImmediately && !isDraining) {
       immediateDrain();
@@ -28139,6 +28194,15 @@ This is often caused by modifying a signal in an already rendered component duri
     }, delay2);
   }
   function applyJournalFlush() {
+    if (blockingChoresCount > 0) {
+      DEBUG6 && debugTrace(
+        `journalFlush.BLOCKED (${blockingChoresCount} blocking chores)`,
+        null,
+        choreQueue,
+        blockedChores
+      );
+      return;
+    }
     if (!isJournalFlushRunning) {
       isJournalFlushRunning = true;
       journalFlush();
@@ -28204,7 +28268,7 @@ This is often caused by modifying a signal in an already rendered component duri
             if (vnode_isVNode(blockedChore.$host$)) {
               blockedChore.$host$.blockedChores?.delete(blockedChore);
             }
-            addChore(blockedChore, choreQueue);
+            addChoreAndIncrementBlockingCounter(blockedChore, choreQueue);
             DEBUG6 && debugTrace("schedule.UNBLOCKED", blockedChore, choreQueue, blockedChores);
             blockedChoresScheduled = true;
           }
@@ -28215,7 +28279,6 @@ This is often caused by modifying a signal in an already rendered component duri
         drainInNextTick();
       }
     };
-    let currentChore = null;
     try {
       while (choreQueue.length) {
         currentTime = performance.now();
@@ -28229,6 +28292,9 @@ This is often caused by modifying a signal in an already rendered component duri
           if (vnode_isVNode(chore.$host$)) {
             chore.$host$.chores?.delete(chore);
           }
+          if (isRenderBlocking(chore.$type$)) {
+            blockingChoresCount--;
+          }
           continue;
         }
         if (chore.$type$ === 16 /* VISIBLE */) {
@@ -28290,12 +28356,32 @@ This is often caused by modifying a signal in an already rendered component duri
     if (vnode_isVNode(chore.$host$)) {
       chore.$host$.chores?.delete(chore);
     }
-    DEBUG6 && debugTrace("execute.DONE", chore, choreQueue, blockedChores);
+    if (isRenderBlocking(chore.$type$)) {
+      blockingChoresCount--;
+      DEBUG6 && debugTrace(
+        `execute.DONE (blocking ${blockingChoresCount})`,
+        chore,
+        choreQueue,
+        blockedChores
+      );
+    } else {
+      DEBUG6 && debugTrace("execute.DONE", chore, choreQueue, blockedChores);
+    }
   }
   function handleError(chore, e) {
     chore.$endTime$ = performance.now();
     chore.$state$ = 2 /* FAILED */;
-    DEBUG6 && debugTrace("execute.ERROR", chore, choreQueue, blockedChores);
+    if (isRenderBlocking(chore.$type$)) {
+      blockingChoresCount--;
+      DEBUG6 && debugTrace(
+        `execute.ERROR (blocking ${blockingChoresCount})`,
+        chore,
+        choreQueue,
+        blockedChores
+      );
+    } else {
+      DEBUG6 && debugTrace("execute.ERROR", chore, choreQueue, blockedChores);
+    }
     chore.$reject$?.(e);
     container.handleError(e, chore.$host$);
   }
@@ -28354,18 +28440,21 @@ This is often caused by modifying a signal in an already rendered component duri
               host
             );
           } else {
-            returnValue = runTask(
-              payload,
-              container,
-              host
-            );
+            const task = payload;
+            returnValue = runTask(task, container, host);
+            if (task.$flags$ & 16 /* RENDER_BLOCKING */) {
+              blockingChoresCount++;
+              returnValue = maybeThen(returnValue, () => {
+                blockingChoresCount--;
+              });
+            }
           }
         }
         break;
       case 32 /* CLEANUP_VISIBLE */:
         {
           const task = chore.$payload$;
-          cleanupTask(task);
+          cleanupDestroyable(task);
         }
         break;
       case 4 /* NODE_DIFF */:
@@ -28468,7 +28557,23 @@ This is often caused by modifying a signal in an already rendered component duri
     }
     return null;
   }
+  function addChoreAndIncrementBlockingCounter(chore, choreArray) {
+    if (addChore(chore, choreArray)) {
+      blockingChoresCount++;
+    }
+  }
 };
+function addChore(chore, choreArray) {
+  var _a5;
+  const idx = choreArray.add(chore);
+  if (idx < 0) {
+    if (vnode_isVNode(chore.$host$)) {
+      ((_a5 = chore.$host$).chores || (_a5.chores = new ChoreArray())).add(chore);
+    }
+    return isRenderBlocking(chore.$type$);
+  }
+  return false;
+}
 function vNodeAlreadyDeleted(chore) {
   return !!(chore.$host$ && vnode_isVNode(chore.$host$) && chore.$host$.flags & 32 /* Deleted */);
 }
@@ -28486,12 +28591,8 @@ function addBlockedChore(blockedChore, blockingChore, blockedChores) {
     ((_a5 = blockedChore.$host$).blockedChores || (_a5.blockedChores = new ChoreArray())).add(blockedChore);
   }
 }
-function addChore(chore, choreArray) {
-  var _a5;
-  const idx = choreArray.add(chore);
-  if (idx < 0 && vnode_isVNode(chore.$host$)) {
-    ((_a5 = chore.$host$).chores || (_a5.chores = new ChoreArray())).add(chore);
-  }
+function isRenderBlocking(type) {
+  return type === 4 /* NODE_DIFF */ || type === 6 /* COMPONENT */;
 }
 function choreTypeToName(type) {
   return {
@@ -28713,15 +28814,16 @@ function qrlToString(serializationContext, value, raw) {
     chunk = "";
     symbol = String(serializationContext.$addSyncFn$(null, 0, fn));
   }
-  if (!value.$capture$ && Array.isArray(value.$captureRef$) && value.$captureRef$.length > 0) {
-    value.$capture$ = value.$captureRef$.map((ref) => `${serializationContext.$addRoot$(ref)}`);
+  let capturedIds = null;
+  if (Array.isArray(value.$captureRef$) && value.$captureRef$.length > 0) {
+    capturedIds = value.$captureRef$.map((ref) => `${serializationContext.$addRoot$(ref)}`);
   }
   if (raw) {
-    return [chunk, symbol, value.$capture$];
+    return [chunk, symbol, capturedIds];
   }
   let qrlStringInline = `${chunk}#${symbol}`;
-  if (value.$capture$ && value.$capture$.length > 0) {
-    qrlStringInline += `[${value.$capture$.join(" ")}]`;
+  if (capturedIds && capturedIds.length > 0) {
+    qrlStringInline += `[${capturedIds.join(" ")}]`;
   }
   return qrlStringInline;
 }
@@ -29992,6 +30094,7 @@ var inflate = (container, target, typeId, data) => {
       const hasValue = d2.length > 6;
       if (hasValue) {
         asyncComputed.$untrackedValue$ = d2[6];
+        asyncComputed.$promiseValue$ = d2[6];
       }
       asyncComputed.$flags$ |= 1 /* INVALID */;
       break;
@@ -30974,6 +31077,9 @@ var DomContainer = class extends _SharedContainer {
     this.$setServerData$();
     element.setAttribute(QContainerAttr, "resumed" /* RESUMED */);
     element.qContainer = this;
+    if (!qTest && element.isConnected) {
+      element.dispatchEvent(new CustomEvent("qresume", { bubbles: true }));
+    }
     const qwikStates = element.querySelectorAll('script[type="qwik/state"]');
     if (qwikStates.length !== 0) {
       const lastState = qwikStates[qwikStates.length - 1];

package/dist/testing/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qwik.dev/core/testing",
-  "version": "2.0.0-beta.13-dev+cb19ff7",
+  "version": "2.0.0-beta.14-dev+1e7496d",
   "main": "index.mjs",
   "types": "index.d.ts",
   "private": true,