@wsxjs/wsx-core 0.0.23 → 0.0.24

package/dist/jsx.js

@@ -100,6 +100,7 @@ var _RenderContext = class _RenderContext {
    * @param fn The function to execute (usually the render method).
    */
   static runInContext(component, fn) {
+    resetCounterForNewRenderCycle(component);
     const prev = _RenderContext.current;
     _RenderContext.current = component;
     try {
@@ -125,21 +126,20 @@ _RenderContext.current = null;
 var RenderContext = _RenderContext;
 
 // src/utils/cache-key.ts
-var POSITION_ID_KEY = "__wsxPositionId";
 var INDEX_KEY = "__wsxIndex";
 var componentElementCounters = /* @__PURE__ */ new WeakMap();
 var componentIdCache = /* @__PURE__ */ new WeakMap();
 function generateCacheKey(tag, props, componentId, component) {
-  const positionId = props?.[POSITION_ID_KEY];
   const userKey = props?.key;
   const index = props?.[INDEX_KEY];
+  const positionId = props?.__wsxPositionId;
   if (userKey !== void 0 && userKey !== null) {
     return `${componentId}:${tag}:key-${String(userKey)}`;
   }
   if (index !== void 0 && index !== null) {
     return `${componentId}:${tag}:idx-${String(index)}`;
   }
-  if (positionId !== void 0 && positionId !== null && positionId !== "no-id") {
+  if (positionId !== void 0 && positionId !== null) {
     return `${componentId}:${tag}:${String(positionId)}`;
   }
   if (component) {
@@ -150,6 +150,9 @@ function generateCacheKey(tag, props, componentId, component) {
   }
   return `${componentId}:${tag}:fallback-${Date.now()}-${Math.random()}`;
 }
+function resetCounterForNewRenderCycle(component) {
+  componentElementCounters.set(component, 0);
+}
 function getComponentId() {
   const component = RenderContext.getCurrentComponent();
   if (component) {
@@ -567,7 +570,9 @@ function applySingleProp(element, key, value, tag, isSVG) {
   }
   if (key.startsWith("on") && typeof value === "function") {
     const eventName = key.slice(2).toLowerCase();
+    const listenerKey = `__wsxListener_${eventName}`;
     element.addEventListener(eventName, value);
+    element[listenerKey] = value;
     return;
   }
   if (typeof value === "boolean") {
@@ -662,7 +667,7 @@ function findElementNode(oldChild, parent) {
 function findTextNode(parent, domIndex) {
   while (domIndex.value < parent.childNodes.length) {
     const node = parent.childNodes[domIndex.value];
-    if (node.nodeType === Node.TEXT_NODE) {
+    if (node.nodeType === Node.TEXT_NODE && node.parentNode === parent) {
       const textNode = node;
       domIndex.value++;
       return textNode;
@@ -676,13 +681,23 @@ function updateOrCreateTextNode(parent, oldNode, newText) {
     if (oldNode.textContent !== newText) {
       oldNode.textContent = newText;
     }
+    return oldNode;
   } else {
+    if (!oldNode) {
+      for (let i = 0; i < parent.childNodes.length; i++) {
+        const node = parent.childNodes[i];
+        if (node.nodeType === Node.TEXT_NODE && node.parentNode === parent && node.textContent === newText) {
+          return node;
+        }
+      }
+    }
     const newTextNode = document.createTextNode(newText);
     if (oldNode && !shouldPreserveElement(oldNode)) {
       parent.replaceChild(newTextNode, oldNode);
     } else {
       parent.insertBefore(newTextNode, oldNode || null);
     }
+    return newTextNode;
   }
 }
 function removeNodeIfNotPreserved(parent, node) {
@@ -691,29 +706,66 @@ function removeNodeIfNotPreserved(parent, node) {
   }
 }
 function replaceOrInsertElement(parent, newChild, oldNode) {
+  const targetNextSibling = oldNode && shouldPreserveElement(oldNode) ? oldNode : oldNode?.nextSibling || null;
+  replaceOrInsertElementAtPosition(parent, newChild, oldNode, targetNextSibling);
+}
+function replaceOrInsertElementAtPosition(parent, newChild, oldNode, targetNextSibling) {
   if (newChild.parentNode && newChild.parentNode !== parent) {
     newChild.parentNode.removeChild(newChild);
   }
-  if (oldNode && !shouldPreserveElement(oldNode)) {
+  const isInCorrectPosition = newChild.parentNode === parent && newChild.nextSibling === targetNextSibling;
+  if (isInCorrectPosition) {
+    return;
+  }
+  if (newChild.parentNode === parent) {
+    parent.insertBefore(newChild, targetNextSibling);
+    return;
+  }
+  if (oldNode && oldNode.parentNode === parent && !shouldPreserveElement(oldNode)) {
     if (oldNode !== newChild) {
       parent.replaceChild(newChild, oldNode);
     }
-  } else if (newChild.parentNode !== parent) {
-    parent.insertBefore(newChild, oldNode || null);
+  } else {
+    if (newChild.parentNode === parent) {
+      return;
+    }
+    const newChildCacheKey = getElementCacheKey(newChild);
+    if (!newChildCacheKey) {
+      const newChildContent = newChild.textContent || "";
+      const newChildTag = newChild.tagName.toLowerCase();
+      for (let i = 0; i < parent.childNodes.length; i++) {
+        const existingNode = parent.childNodes[i];
+        if (existingNode instanceof HTMLElement || existingNode instanceof SVGElement) {
+          const existingCacheKey = getElementCacheKey(existingNode);
+          if (!existingCacheKey && existingNode.tagName.toLowerCase() === newChildTag && existingNode.textContent === newChildContent && existingNode !== newChild) {
+            return;
+          }
+        }
+      }
+    }
+    parent.insertBefore(newChild, targetNextSibling);
   }
 }
-function appendNewChild(parent, child) {
+function appendNewChild(parent, child, processedNodes) {
   if (child === null || child === void 0 || child === false) {
     return;
   }
   if (typeof child === "string" || typeof child === "number") {
-    parent.appendChild(document.createTextNode(String(child)));
+    const newTextNode = document.createTextNode(String(child));
+    parent.appendChild(newTextNode);
+    if (processedNodes) {
+      processedNodes.add(newTextNode);
+    }
   } else if (child instanceof HTMLElement || child instanceof SVGElement) {
+    if (child.parentNode === parent) {
+      return;
+    }
     if (child.parentNode && child.parentNode !== parent) {
       child.parentNode.removeChild(child);
     }
-    if (child.parentNode !== parent) {
-      parent.appendChild(child);
+    parent.appendChild(child);
+    if (processedNodes) {
+      processedNodes.add(child);
     }
   } else if (child instanceof DocumentFragment) {
     parent.appendChild(child);
@@ -735,10 +787,22 @@ function buildNewChildrenMaps(flatNew) {
   }
   return { elementSet, cacheKeyMap };
 }
-function shouldRemoveNode(node, elementSet, cacheKeyMap) {
+function shouldRemoveNode(node, elementSet, cacheKeyMap, processedNodes) {
   if (shouldPreserveElement(node)) {
     return false;
   }
+  if (node.nodeType === Node.TEXT_NODE && processedNodes && processedNodes.has(node)) {
+    return false;
+  }
+  if (node.nodeType === Node.TEXT_NODE && processedNodes) {
+    let parent = node.parentNode;
+    while (parent) {
+      if (processedNodes.has(parent) && parent.parentNode) {
+        return false;
+      }
+      parent = parent.parentNode;
+    }
+  }
   if (node instanceof HTMLElement || node instanceof SVGElement || node instanceof DocumentFragment) {
     if (elementSet.has(node)) {
       return false;
@@ -767,24 +831,39 @@ function deduplicateCacheKeys(parent, cacheKeyMap) {
         if (child !== newChild) {
           parent.replaceChild(newChild, child);
         }
+      } else if (cacheKey && cacheKeyMap.has(cacheKey) && processedCacheKeys.has(cacheKey)) {
+        const newChild = cacheKeyMap.get(cacheKey);
+        if (child !== newChild) {
+          parent.removeChild(child);
+        }
       }
     }
   }
 }
-function collectNodesToRemove(parent, elementSet, cacheKeyMap) {
+function collectNodesToRemove(parent, elementSet, cacheKeyMap, processedNodes) {
   const nodesToRemove = [];
   for (let i = 0; i < parent.childNodes.length; i++) {
     const node = parent.childNodes[i];
-    if (shouldRemoveNode(node, elementSet, cacheKeyMap)) {
+    if (shouldRemoveNode(node, elementSet, cacheKeyMap, processedNodes)) {
       nodesToRemove.push(node);
     }
   }
   return nodesToRemove;
 }
-function removeNodes(parent, nodes) {
+function removeNodes(parent, nodes, cacheManager) {
   for (let i = nodes.length - 1; i >= 0; i--) {
     const node = nodes[i];
     if (node.parentNode === parent) {
+      if (cacheManager && (node instanceof HTMLElement || node instanceof SVGElement)) {
+        const metadata = cacheManager.getMetadata(node);
+        const refCallback = metadata?.ref;
+        if (typeof refCallback === "function") {
+          try {
+            refCallback(null);
+          } catch {
+          }
+        }
+      }
       parent.removeChild(node);
     }
   }
@@ -804,6 +883,12 @@ function flattenChildrenSafe(children) {
 function removeProp(element, key, oldValue, tag) {
   const isSVG = shouldUseSVGNamespace(tag);
   if (key === "ref") {
+    if (typeof oldValue === "function") {
+      try {
+        oldValue(null);
+      } catch {
+      }
+    }
     return;
   }
   if (key === "className" || key === "class") {
@@ -819,6 +904,13 @@ function removeProp(element, key, oldValue, tag) {
     return;
   }
   if (key.startsWith("on") && typeof oldValue === "function") {
+    const eventName = key.slice(2).toLowerCase();
+    const listenerKey = `__wsxListener_${eventName}`;
+    const savedListener = element[listenerKey];
+    if (savedListener) {
+      element.removeEventListener(eventName, savedListener);
+      delete element[listenerKey];
+    }
     return;
   }
   if (key === "value") {
@@ -862,7 +954,13 @@ function applySingleProp2(element, key, value, tag, isSVG) {
   }
   if (key.startsWith("on") && typeof value === "function") {
     const eventName = key.slice(2).toLowerCase();
+    const listenerKey = `__wsxListener_${eventName}`;
+    const oldListener = element[listenerKey];
+    if (oldListener) {
+      element.removeEventListener(eventName, oldListener);
+    }
     element.addEventListener(eventName, value);
+    element[listenerKey] = value;
     return;
   }
   if (typeof value === "boolean") {
@@ -917,12 +1015,13 @@ function updateProps(element, oldProps, newProps, tag) {
     applySingleProp2(element, key, newValue, tag, isSVG);
   }
 }
-function updateChildren(element, oldChildren, newChildren, cacheManager) {
+function updateChildren(element, oldChildren, newChildren, _cacheManager) {
   const flatOld = flattenChildrenSafe(oldChildren);
   const flatNew = flattenChildrenSafe(newChildren);
   const preservedElements = collectPreservedElements(element);
   const minLength = Math.min(flatOld.length, flatNew.length);
   const domIndex = { value: 0 };
+  const processedNodes = /* @__PURE__ */ new Set();
   for (let i = 0; i < minLength; i++) {
     const oldChild = flatOld[i];
     const newChild = flatNew[i];
@@ -938,9 +1037,10 @@ function updateChildren(element, oldChildren, newChildren, cacheManager) {
     } else if (typeof oldChild === "string" || typeof oldChild === "number") {
       oldNode = findTextNode(element, domIndex);
       if (!oldNode && element.childNodes.length > 0) {
+        const oldText = String(oldChild);
         for (let j = domIndex.value; j < element.childNodes.length; j++) {
           const node = element.childNodes[j];
-          if (node.nodeType === Node.TEXT_NODE) {
+          if (node.nodeType === Node.TEXT_NODE && node.parentNode === element && node.textContent === oldText) {
             oldNode = node;
             domIndex.value = j + 1;
             break;
@@ -954,7 +1054,14 @@ function updateChildren(element, oldChildren, newChildren, cacheManager) {
         const newText = String(newChild);
         const needsUpdate = oldText !== newText || oldNode && oldNode.nodeType === Node.TEXT_NODE && oldNode.textContent !== newText;
         if (needsUpdate) {
-          updateOrCreateTextNode(element, oldNode, newText);
+          const updatedNode = updateOrCreateTextNode(element, oldNode, newText);
+          if (updatedNode && !processedNodes.has(updatedNode)) {
+            processedNodes.add(updatedNode);
+          }
+        } else {
+          if (oldNode && oldNode.parentNode === element) {
+            processedNodes.add(oldNode);
+          }
         }
       } else {
         removeNodeIfNotPreserved(element, oldNode);
@@ -968,30 +1075,48 @@ function updateChildren(element, oldChildren, newChildren, cacheManager) {
       if (oldNode && shouldPreserveElement(oldNode)) {
         continue;
       }
-      if (newChild === oldChild && (newChild instanceof HTMLElement || newChild instanceof SVGElement)) {
-        if (cacheManager) {
-          const childMetadata = cacheManager.getMetadata(newChild);
-          if (childMetadata) {
-            if (oldNode === newChild && newChild.parentNode === element) {
-              continue;
+      if (newChild instanceof HTMLElement || newChild instanceof SVGElement) {
+        let targetNextSibling = null;
+        let foundPreviousElement = false;
+        for (let j = i - 1; j >= 0; j--) {
+          const prevChild = flatNew[j];
+          if (prevChild instanceof HTMLElement || prevChild instanceof SVGElement) {
+            if (prevChild.parentNode === element) {
+              targetNextSibling = prevChild.nextSibling;
+              foundPreviousElement = true;
+              break;
             }
           }
-        } else {
-          if (oldNode === newChild && newChild.parentNode === element) {
-            continue;
-          }
         }
-      }
-      if (newChild instanceof HTMLElement || newChild instanceof SVGElement) {
-        if (newChild.parentNode === element && oldNode === newChild) {
+        if (!foundPreviousElement) {
+          const firstChild = Array.from(element.childNodes).find(
+            (node) => !shouldPreserveElement(node) && !processedNodes.has(node)
+          );
+          targetNextSibling = firstChild || null;
+        }
+        const isInCorrectPosition = newChild.parentNode === element && newChild.nextSibling === targetNextSibling;
+        if (newChild === oldChild && isInCorrectPosition) {
+          if (oldNode) processedNodes.add(oldNode);
+          processedNodes.add(newChild);
           continue;
         }
-        replaceOrInsertElement(element, newChild, oldNode);
+        const referenceNode = oldNode && oldNode.parentNode === element ? oldNode : null;
+        replaceOrInsertElementAtPosition(
+          element,
+          newChild,
+          referenceNode,
+          targetNextSibling
+        );
+        if (oldNode && oldNode !== newChild) {
+          processedNodes.delete(oldNode);
+        }
+        processedNodes.add(newChild);
       } else {
         removeNodeIfNotPreserved(element, oldNode);
         if (typeof newChild === "string" || typeof newChild === "number") {
           const newTextNode = document.createTextNode(String(newChild));
           element.insertBefore(newTextNode, oldNode?.nextSibling || null);
+          processedNodes.add(newTextNode);
         } else if (newChild instanceof DocumentFragment) {
           element.insertBefore(newChild, oldNode?.nextSibling || null);
         }
@@ -999,12 +1124,12 @@ function updateChildren(element, oldChildren, newChildren, cacheManager) {
     }
   }
   for (let i = minLength; i < flatNew.length; i++) {
-    appendNewChild(element, flatNew[i]);
+    appendNewChild(element, flatNew[i], processedNodes);
   }
   const { elementSet, cacheKeyMap } = buildNewChildrenMaps(flatNew);
   deduplicateCacheKeys(element, cacheKeyMap);
-  const nodesToRemove = collectNodesToRemove(element, elementSet, cacheKeyMap);
-  removeNodes(element, nodesToRemove);
+  const nodesToRemove = collectNodesToRemove(element, elementSet, cacheKeyMap, processedNodes);
+  removeNodes(element, nodesToRemove, _cacheManager);
   reinsertPreservedElements(element, preservedElements);
 }
 function updateElement(element, newProps, newChildren, tag, cacheManager) {

package/dist/jsx.mjs

@@ -1,7 +1,7 @@
 import {
   Fragment,
   h
-} from "./chunk-ESZYREJK.mjs";
+} from "./chunk-5Q2VEEUH.mjs";
 export {
   Fragment,
   h