@qwik.dev/core 2.0.0-beta.25 → 2.0.0-beta.26

package/dist/core.mjs

@@ -1,6 +1,6 @@
 /**
  * @license
- * @qwik.dev/core 2.0.0-beta.25-dev+2677279
+ * @qwik.dev/core 2.0.0-beta.26-dev+c693cf5
  * 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
@@ -1007,7 +1007,7 @@ const COMMA = ',';
  *
  * @public
  */
-const version = "2.0.0-beta.25-dev+2677279";
+const version = "2.0.0-beta.26-dev+c693cf5";
 
 // keep this import from core/build so the cjs build works
 const createPlatform = () => {
@@ -1020,6 +1020,8 @@ const createPlatform = () => {
                 if (regSym) {
                     return regSym;
                 }
+                // we never lazy import on the server
+                throw qError(6 /* QError.dynamicImportFailed */, [symbolName]);
             }
             if (!url) {
                 throw qError(14 /* QError.qrlMissingChunk */, [symbolName]);
@@ -3705,7 +3707,14 @@ const cleanupDestroyable = (destroyable) => {
  * This safely calls an event handler, handling errors and retrying on thrown Promises, and
  * providing extra parameters defined on the elements as arguments (used for loop optimization)
  */
-function runEventHandlerQRL(handler, event, element, ctx = newInvokeContextFromDOM(event, element)) {
+function runEventHandlerQRL(handler, event, element, ctx) {
+    if (!element.isConnected) {
+        // ignore events on disconnected elements, this can happen when the event is triggered while the element is being removed
+        return;
+    }
+    if (!ctx) {
+        ctx = newInvokeContextFromDOM(event, element);
+    }
     const container = ctx.$container$;
     const hostElement = ctx.$hostElement$;
     vnode_ensureElementInflated(container, hostElement);
@@ -3770,8 +3779,8 @@ function setAttribute(journal, vnode, key, value, scopedStyleIdPrefix, originalV
     vnode_setProp(vnode, key, originalValue);
     addVNodeOperation(journal, createSetAttributeOperation(vnode.node, key, value, scopedStyleIdPrefix, (vnode.flags & 512 /* VNodeFlags.NS_svg */) !== 0));
 }
-const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
-    const diffContext = {
+function createDiffContext(container, journal, cursor, scopedStyleIdPrefix) {
+    return {
         container,
         journal,
         cursor,
@@ -3802,6 +3811,9 @@ const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyle
             }),
         },
     };
+}
+const vnode_diff = (container, journal, jsxNode, vStartNode, cursor, scopedStyleIdPrefix) => {
+    const diffContext = createDiffContext(container, journal, cursor, scopedStyleIdPrefix);
     ////////////////////////////////
     diff(diffContext, jsxNode, vStartNode);
     const result = drainAsyncQueue(diffContext);
@@ -4156,6 +4168,7 @@ function expectSlot(diffContext) {
         vHost && vnode_setProp(vHost, slotNameKey, diffContext.vNewNode);
         isDev &&
             vnode_setProp(diffContext.vNewNode, DEBUG_TYPE, "P" /* VirtualType.Projection */);
+        vnode_inflateProjectionTrailingText(diffContext.journal, diffContext.vNewNode);
         vnode_insertBefore(diffContext.journal, diffContext.vParent, diffContext.vNewNode, diffContext.vCurrent && getInsertBefore(diffContext));
         // If we moved from a q:template and it's now empty, remove it
         if (oldParent &&
@@ -4706,26 +4719,34 @@ function expectComponent(diffContext, component) {
         const vNodeLookupKey = getKey(host) || vNodeComponentHash;
         const lookupKeysAreEqual = lookupKey === vNodeLookupKey;
         const hashesAreEqual = componentHash === vNodeComponentHash;
-        if (!lookupKeysAreEqual) {
-            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.vParent)) {
+        if (lookupKeysAreEqual) {
+            if (hashesAreEqual) {
+                deleteFromSideBuffer(diffContext, null, lookupKey);
+            }
+            else {
                 insertNewComponent(diffContext, host, componentQRL, jsxProps);
+                host = diffContext.vNewNode;
                 shouldRender = true;
             }
-            host = (diffContext.vNewNode || diffContext.vCurrent);
-        }
-        else if (!hashesAreEqual || !jsxNode.key) {
-            insertNewComponent(diffContext, host, componentQRL, jsxProps);
-            host = diffContext.vNewNode;
-            shouldRender = true;
         }
         else {
-            // delete the key from the side buffer if it is the same component
-            deleteFromSideBuffer(diffContext, null, lookupKey);
+            if (moveOrCreateKeyedNode(diffContext, null, lookupKey, lookupKey, diffContext.vParent)) {
+                insertNewComponent(diffContext, host, componentQRL, jsxProps);
+                shouldRender = true;
+            }
+            host = (diffContext.vNewNode || diffContext.vCurrent);
         }
         if (host) {
             const vNodeProps = vnode_getProp(host, ELEMENT_PROPS, diffContext.container.$getObjectById$);
             if (!shouldRender) {
-                shouldRender ||= handleProps(host, jsxProps, vNodeProps, diffContext.container);
+                const propsChanged = handleProps(host, jsxProps, vNodeProps, diffContext.container);
+                // if props changed but key is null we need to insert a new component, because we need to execute hooks etc
+                if (propsChanged && jsxNode.key == null) {
+                    insertNewComponent(diffContext, host, componentQRL, jsxProps);
+                    host = diffContext.vNewNode;
+                    shouldRender = true;
+                }
+                shouldRender ||= propsChanged;
             }
             if (shouldRender) {
                 // Assign the new QRL instance to the host.
@@ -4747,7 +4768,7 @@ function expectComponent(diffContext, component) {
         const lookupKeysAreEqual = lookupKey === vNodeLookupKey;
         const vNodeComponentHash = getComponentHash(host, diffContext.container.$getObjectById$);
         const isInlineComponent = vNodeComponentHash == null;
-        if ((host && !isInlineComponent) || lookupKey == null) {
+        if ((host && !isInlineComponent) || !host) {
             insertNewInlineComponent(diffContext);
             host = diffContext.vNewNode;
         }
@@ -5739,7 +5760,7 @@ function walkCursor(cursor, options) {
             return;
         }
         // Check time budget (only for DOM, not SSR)
-        if (!isRunningOnServer && !import.meta.env.TEST) {
+        if (isBrowser) {
             const elapsed = performance.now() - startTime;
             if (elapsed >= timeBudget) {
                 // Schedule continuation as macrotask to actually yield to browser
@@ -5781,10 +5802,27 @@ function tryDescendDirtyChildren(container, cursorData, currentVNode, cursor) {
         return null;
     }
     partitionDirtyChildren(dirtyChildren, currentVNode);
+    // Scan dirtyChildren directly instead of going through getNextVNode.
+    // getNextVNode follows the child's parent/slotParent pointer, which for Projection nodes
+    // points to the DOM insertion location rather than currentVNode — that would scan the
+    // wrong dirtyChildren array and potentially cause infinite loops.
+    // const len = dirtyChildren.length;
+    // for (let i = 0; i < len; i++) {
+    //   const child = dirtyChildren[i];
+    //   if (child.dirty & ChoreBits.DIRTY_MASK) {
+    //     currentVNode.nextDirtyChildIndex = (i + 1) % len;
+    //     setCursorPosition(container, cursorData, child);
+    //     return child;
+    //   }
+    // }
+    // // No dirty child found — clean up
+    // currentVNode.dirty &= ~ChoreBits.CHILDREN;
+    // currentVNode.dirtyChildren = null;
     currentVNode.nextDirtyChildIndex = 0;
     const next = getNextVNode(dirtyChildren[0], cursor);
     setCursorPosition(container, cursorData, next);
     return next;
+    // return null;
 }
 /**
  * Partitions dirtyChildren array so non-projections come first, projections last. Uses in-place
@@ -5813,14 +5851,14 @@ function getNextVNode(vNode, cursor) {
         }
         return null;
     }
-    // Prefer parent if it's dirty, otherwise try slotParent
+    // Prefer slotParent (logical owner) for Projections, fall back to parent
     let parent = null;
-    if (vNode.parent && vNode.parent.dirty & 32 /* ChoreBits.CHILDREN */) {
-        parent = vNode.parent;
-    }
-    else if (vNode.slotParent && vNode.slotParent.dirty & 32 /* ChoreBits.CHILDREN */) {
+    if (vNode.slotParent && vNode.slotParent.dirty & 32 /* ChoreBits.CHILDREN */) {
         parent = vNode.slotParent;
     }
+    else if (vNode.parent && vNode.parent.dirty & 32 /* ChoreBits.CHILDREN */) {
+        parent = vNode.parent;
+    }
     if (!parent) {
         if (cursor.dirty & 127 /* ChoreBits.DIRTY_MASK */) {
             return cursor;
@@ -5992,7 +6030,9 @@ function propagatePath(target) {
         const parent = reusablePath[i + 1] || target;
         parent.dirty |= 32 /* ChoreBits.CHILDREN */;
         parent.dirtyChildren ||= [];
-        parent.dirtyChildren.push(child);
+        if (!parent.dirtyChildren.includes(child)) {
+            parent.dirtyChildren.push(child);
+        }
     }
 }
 /**
@@ -6001,7 +6041,7 @@ function propagatePath(target) {
  */
 function propagateToCursorRoot(vNode, cursorRoot) {
     reusablePath.push(vNode);
-    let current = vNode.parent || vNode.slotParent;
+    let current = vNode.slotParent || vNode.parent;
     while (current) {
         const isDirty = current.dirty & 127 /* ChoreBits.DIRTY_MASK */;
         const currentIsCursor = isCursor(current);
@@ -6026,7 +6066,7 @@ function propagateToCursorRoot(vNode, cursorRoot) {
             }
         }
         reusablePath.push(current);
-        current = current.parent || current.slotParent;
+        current = current.slotParent || current.parent;
     }
     reusablePath.length = 0;
     throwErrorAndStop('Cursor root not found in current path!');
@@ -6037,7 +6077,7 @@ function propagateToCursorRoot(vNode, cursorRoot) {
  */
 function findAndPropagateToBlockingCursor(vNode) {
     reusablePath.push(vNode);
-    let current = vNode.parent || vNode.slotParent;
+    let current = vNode.slotParent || vNode.parent;
     while (current) {
         const currentIsCursor = isCursor(current);
         if (currentIsCursor) {
@@ -6046,7 +6086,7 @@ function findAndPropagateToBlockingCursor(vNode) {
             return true;
         }
         reusablePath.push(current);
-        current = current.parent || current.slotParent;
+        current = current.slotParent || current.parent;
     }
     reusablePath.length = 0;
     return false;
@@ -6080,7 +6120,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
     if ((isRealDirty ? prevDirty & 127 /* ChoreBits.DIRTY_MASK */ : prevDirty) || vNode === cursorRoot) {
         return;
     }
-    const parent = vNode.parent || vNode.slotParent;
+    const parent = vNode.slotParent || vNode.parent;
     // If cursorRoot is provided, propagate up to it
     if (cursorRoot && isRealDirty && parent && !parent.dirty) {
         propagateToCursorRoot(vNode, cursorRoot);
@@ -6092,7 +6132,9 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
             parent.dirty |= 32 /* ChoreBits.CHILDREN */;
         }
         parent.dirtyChildren ||= [];
-        parent.dirtyChildren.push(vNode);
+        if (!parent.dirtyChildren.includes(vNode)) {
+            parent.dirtyChildren.push(vNode);
+        }
         if (isRealDirty && vNode.dirtyChildren) {
             // this node is maybe an ancestor of the current cursor position
             // if so we must restart from here
@@ -6103,7 +6145,7 @@ function markVNodeDirty(container, vNode, bits, cursorRoot = null) {
                 if (cursorPosition) {
                     // find the ancestor of the cursor position that is current vNode
                     while (cursorPosition !== cursor) {
-                        cursorPosition = cursorPosition.parent || cursorPosition.slotParent;
+                        cursorPosition = cursorPosition.slotParent || cursorPosition.parent;
                         if (cursorPosition === vNode) {
                             // set cursor position to this node
                             cursorData.position = vNode;
@@ -6487,7 +6529,7 @@ function vnode_walkVNode(vNode, callback) {
     let vCursor = vNode;
     // Depth first traversal
     if (vnode_isTextVNode(vNode)) {
-        // Text nodes don't have subscriptions or children;
+        callback?.(vNode, null);
         return;
     }
     let vParent = null;
@@ -6635,11 +6677,6 @@ const vnode_getDomSibling = (vNode, nextDirection, descend) => {
     }
     return null;
 };
-const vnode_ensureInflatedIfText = (journal, vNode) => {
-    if (vnode_isTextVNode(vNode)) {
-        vnode_ensureTextInflated(journal, vNode);
-    }
-};
 const vnode_ensureTextInflated = (journal, vnode) => {
     const textVNode = ensureTextVNode(vnode);
     const flags = textVNode.flags;
@@ -6965,7 +7002,9 @@ const vnode_findInsertBefore = (journal, parent, insertBefore) => {
     else {
         adjustedInsertBefore = insertBefore;
     }
-    adjustedInsertBefore && vnode_ensureInflatedIfText(journal, adjustedInsertBefore);
+    adjustedInsertBefore &&
+        vnode_isTextVNode(adjustedInsertBefore) &&
+        vnode_ensureTextInflated(journal, adjustedInsertBefore);
     return adjustedInsertBefore;
 };
 const vnode_connectSiblings = (parent, vNode, vNext) => {
@@ -7029,6 +7068,45 @@ const vnode_unlinkFromOldParent = (journal, currentParent, newParent, newChild)
         vnode_remove(journal, currentParent, newChild, false);
     }
 };
+/**
+ * When a projection vnode is about to be repositioned (moved in the vnode tree), its trailing text
+ * node must be inflated before the projection is unlinked from its current sibling chain.
+ * `vnode_ensureTextInflated` relies on `vnode_getDomSibling` to locate adjacent text nodes and
+ * decide which one is "last" (i.e. the one that gets to reuse the shared SSR DOM `Text` node). Once
+ * the projection is unlinked, its `nextSibling` becomes `null`, so `getDomSibling` can no longer
+ * cross the boundary to find a trailing sibling such as an empty-string text node — causing
+ * `isLastNode` to be `true` prematurely and corrupting the shared DOM text node. Inflating the
+ * trailing text node while the siblings are still connected gives it its own fresh DOM node and
+ * avoids the corruption.
+ *
+ * Example:
+ *
+ * ```
+ * <Component>
+ *   <button>
+ *     <InlineComponent>
+ *       <span>
+ *         "*"
+ *       </span>
+ *     </InlineComponent>
+ *     <Projection> // <-- this projection when unlinked from the siblings will cause the "test" text node to be considered the last node without inflating it
+ *       "test" // <-- this text node is sharing the same DOM node with the ""
+ *     </Projection>
+ *     "" <-- this text node is sharing the same DOM node with the "test"
+ *   </button>
+ * </Component>
+ * ```
+ */
+const vnode_inflateProjectionTrailingText = (journal, projection) => {
+    // Follow lastChild through any inner virtual wrappers to reach the actual trailing text node.
+    let last = projection;
+    while (last && vnode_isVirtualVNode(last)) {
+        last = last.lastChild;
+    }
+    if (last && vnode_isTextVNode(last) && (last.flags & 8 /* VNodeFlags.Inflated */) === 0) {
+        vnode_ensureTextInflated(journal, last);
+    }
+};
 const vnode_insertBefore = (journal, parent, newChild, insertBefore) => {
     if (vnode_isElementOrTextVNode(newChild)) {
         vnode_insertElementBefore(journal, parent, newChild, insertBefore);