@wsxjs/wsx-core 0.0.27 → 0.0.28

package/dist/jsx.js

@@ -85,6 +85,17 @@ function flattenChildren(children, skipHTMLDetection = false, depth = 0) {
       } else {
         result.push(child);
       }
+    } else if (child instanceof DocumentFragment) {
+      const fragmentChildren = Array.from(child.childNodes);
+      for (const fragChild of fragmentChildren) {
+        if (fragChild instanceof HTMLElement || fragChild instanceof SVGElement) {
+          result.push(fragChild);
+        } else if (fragChild.nodeType === Node.TEXT_NODE) {
+          result.push(fragChild.textContent || "");
+        } else if (fragChild instanceof DocumentFragment) {
+          result.push(...flattenChildren([fragChild], skipHTMLDetection, depth + 1));
+        }
+      }
     } else {
       result.push(child);
     }
@@ -185,7 +196,7 @@ function isCreatedByH(element) {
 }
 function shouldPreserveElement(element) {
   if (!(element instanceof HTMLElement || element instanceof SVGElement)) {
-    return true;
+    return false;
   }
   if (!isCreatedByH(element)) {
     return true;
@@ -636,7 +647,9 @@ function appendChildrenToElement(element, children) {
       return;
     }
     if (typeof child === "string" || typeof child === "number") {
-      element.appendChild(document.createTextNode(String(child)));
+      const textNode = document.createTextNode(String(child));
+      textNode.__wsxManaged = true;
+      element.appendChild(textNode);
     } else if (child instanceof HTMLElement || child instanceof SVGElement) {
       element.appendChild(child);
     } else if (child instanceof DocumentFragment) {
@@ -656,6 +669,9 @@ function collectPreservedElements(element) {
   const preserved = [];
   for (let i = 0; i < element.childNodes.length; i++) {
     const child = element.childNodes[i];
+    if (child.nodeType === Node.TEXT_NODE) {
+      continue;
+    }
     if (shouldPreserveElement(child)) {
       preserved.push(child);
     }
@@ -689,38 +705,40 @@ function findElementNode(oldChild, parent) {
   }
   return null;
 }
-function findTextNode(parent, domIndex) {
-  while (domIndex.value < parent.childNodes.length) {
-    const node = parent.childNodes[domIndex.value];
-    if (node.nodeType === Node.TEXT_NODE && node.parentNode === parent) {
-      const textNode = node;
-      domIndex.value++;
-      return textNode;
+function findTextNode(parent, domIndex, processedNodes) {
+  for (let i = domIndex.value; i < parent.childNodes.length; i++) {
+    const node = parent.childNodes[i];
+    if (node.nodeType === Node.TEXT_NODE && node.__wsxManaged === true && !processedNodes.has(node)) {
+      domIndex.value = i + 1;
+      return node;
     }
-    domIndex.value++;
   }
   return null;
 }
-function updateOrCreateTextNode(parent, oldNode, newText) {
+function updateOrCreateTextNode(parent, oldNode, newText, insertBeforeNode) {
+  if (shouldPreserveElement(parent)) {
+    if (oldNode && oldNode.nodeType === Node.TEXT_NODE) {
+      return oldNode;
+    }
+    return document.createTextNode(newText);
+  }
   if (oldNode && oldNode.nodeType === Node.TEXT_NODE) {
     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;
-        }
+    if (insertBeforeNode !== void 0) {
+      if (oldNode !== insertBeforeNode && oldNode.nextSibling !== insertBeforeNode) {
+        parent.insertBefore(oldNode, insertBeforeNode);
       }
     }
+    return oldNode;
+  } else {
     const newTextNode = document.createTextNode(newText);
+    newTextNode.__wsxManaged = true;
     if (oldNode && !shouldPreserveElement(oldNode)) {
       parent.replaceChild(newTextNode, oldNode);
     } else {
-      parent.insertBefore(newTextNode, oldNode || null);
+      parent.insertBefore(newTextNode, insertBeforeNode ?? null);
     }
     return newTextNode;
   }
@@ -730,53 +748,13 @@ function removeNodeIfNotPreserved(parent, node) {
     parent.removeChild(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);
-  }
-  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) {
-      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, processedNodes) {
   if (child === null || child === void 0 || child === false) {
     return;
   }
   if (typeof child === "string" || typeof child === "number") {
     const newTextNode = document.createTextNode(String(child));
+    newTextNode.__wsxManaged = true;
     parent.appendChild(newTextNode);
     if (processedNodes) {
       processedNodes.add(newTextNode);
@@ -793,6 +771,11 @@ function appendNewChild(parent, child, processedNodes) {
       processedNodes.add(child);
     }
   } else if (child instanceof DocumentFragment) {
+    if (processedNodes) {
+      for (let i = 0; i < child.childNodes.length; i++) {
+        processedNodes.add(child.childNodes[i]);
+      }
+    }
     parent.appendChild(child);
   }
 }
@@ -813,21 +796,32 @@ function buildNewChildrenMaps(flatNew) {
   return { elementSet, cacheKeyMap };
 }
 function shouldRemoveNode(node, elementSet, cacheKeyMap, processedNodes) {
+  if (node.nodeType === Node.TEXT_NODE) {
+    if (node.__wsxManaged === true) {
+      if (processedNodes && processedNodes.has(node)) {
+        return false;
+      }
+      return true;
+    }
+    const parent = node.parentNode;
+    if (parent && (parent instanceof HTMLElement || parent instanceof SVGElement)) {
+      if (shouldPreserveElement(parent)) {
+        return false;
+      }
+    }
+    return true;
+  } else {
+    if (shouldPreserveElement(node)) {
+      return false;
+    }
+  }
+  const isProcessed = processedNodes && processedNodes.has(node);
   if (shouldPreserveElement(node)) {
     return false;
   }
-  if (node.nodeType === Node.TEXT_NODE && processedNodes && processedNodes.has(node)) {
+  if (node.nodeType === Node.TEXT_NODE && isProcessed) {
     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;
@@ -869,7 +863,8 @@ 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, processedNodes)) {
+    const removed = shouldRemoveNode(node, elementSet, cacheKeyMap, processedNodes);
+    if (removed) {
       nodesToRemove.push(node);
     }
   }
@@ -1071,6 +1066,7 @@ function updateChildren(element, oldChildren, newChildren, _cacheManager) {
   const preservedElements = collectPreservedElements(element);
   const minLength = Math.min(flatOld.length, flatNew.length);
   const domIndex = { value: 0 };
+  const insertionIndex = { value: 0 };
   const processedNodes = /* @__PURE__ */ new Set();
   for (let i = 0; i < minLength; i++) {
     const oldChild = flatOld[i];
@@ -1085,48 +1081,54 @@ 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 && node.parentNode === element && node.textContent === oldText) {
-            oldNode = node;
-            domIndex.value = j + 1;
-            break;
+      if (shouldPreserveElement(element)) {
+        oldNode = null;
+      } else {
+        oldNode = findTextNode(element, domIndex, processedNodes);
+        if (oldNode) {
+          const nodeIndex = Array.from(element.childNodes).indexOf(oldNode);
+          if (nodeIndex !== -1 && nodeIndex >= domIndex.value) {
+            domIndex.value = nodeIndex + 1;
           }
         }
       }
     }
     if (typeof oldChild === "string" || typeof oldChild === "number") {
       if (typeof newChild === "string" || typeof newChild === "number") {
-        const oldText = String(oldChild);
         const newText = String(newChild);
-        const needsUpdate = oldText !== newText || oldNode && oldNode.nodeType === Node.TEXT_NODE && oldNode.textContent !== newText;
-        if (needsUpdate) {
-          const updatedNode = updateOrCreateTextNode(element, oldNode, newText);
-          if (updatedNode && !processedNodes.has(updatedNode)) {
-            processedNodes.add(updatedNode);
-          }
-        } else {
-          if (oldNode && oldNode.parentNode === element) {
-            processedNodes.add(oldNode);
-          } else if (!oldNode && oldText === newText) {
-            for (let j = domIndex.value; j < element.childNodes.length; j++) {
-              const node = element.childNodes[j];
-              if (node.nodeType === Node.TEXT_NODE && node.parentNode === element && node.textContent === newText && !processedNodes.has(node)) {
-                processedNodes.add(node);
-                break;
-              }
-            }
-          }
+        if (shouldPreserveElement(element)) {
+          continue;
+        }
+        const insertBeforeNode = insertionIndex.value < element.childNodes.length ? element.childNodes[insertionIndex.value] : null;
+        const updatedNode = updateOrCreateTextNode(
+          element,
+          oldNode,
+          newText,
+          insertBeforeNode
+        );
+        if (updatedNode) {
+          processedNodes.add(updatedNode);
+          insertionIndex.value++;
         }
       } else {
-        removeNodeIfNotPreserved(element, oldNode);
+        const targetNode = insertionIndex.value < element.childNodes.length ? element.childNodes[insertionIndex.value] : null;
         if (newChild instanceof HTMLElement || newChild instanceof SVGElement) {
-          replaceOrInsertElement(element, newChild, oldNode);
+          if (oldNode && oldNode === targetNode && oldNode.parentNode === element) {
+            element.replaceChild(newChild, oldNode);
+          } else {
+            element.insertBefore(newChild, targetNode);
+            removeNodeIfNotPreserved(element, oldNode);
+          }
+          processedNodes.add(newChild);
+          insertionIndex.value++;
         } else if (newChild instanceof DocumentFragment) {
-          element.insertBefore(newChild, oldNode || null);
+          if (processedNodes) {
+            for (let i2 = 0; i2 < newChild.childNodes.length; i2++) {
+              processedNodes.add(newChild.childNodes[i2]);
+            }
+          }
+          element.insertBefore(newChild, targetNode);
+          removeNodeIfNotPreserved(element, oldNode);
         }
       }
     } else if (oldChild instanceof HTMLElement || oldChild instanceof SVGElement) {
@@ -1134,49 +1136,37 @@ function updateChildren(element, oldChildren, newChildren, _cacheManager) {
         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;
-            }
+        const insertBeforeNode = insertionIndex.value < element.childNodes.length ? element.childNodes[insertionIndex.value] : null;
+        if (newChild === oldNode) {
+          if (newChild.nextSibling !== insertBeforeNode) {
+            element.insertBefore(newChild, insertBeforeNode);
           }
-        }
-        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;
-        }
-        const referenceNode = oldNode && oldNode.parentNode === element ? oldNode : null;
-        replaceOrInsertElementAtPosition(
-          element,
-          newChild,
-          referenceNode,
-          targetNextSibling
-        );
-        if (oldNode && oldNode !== newChild) {
-          processedNodes.delete(oldNode);
+        } else {
+          element.insertBefore(newChild, insertBeforeNode);
         }
         processedNodes.add(newChild);
+        insertionIndex.value++;
       } else {
-        removeNodeIfNotPreserved(element, oldNode);
+        const targetNode = insertionIndex.value < element.childNodes.length ? element.childNodes[insertionIndex.value] : null;
         if (typeof newChild === "string" || typeof newChild === "number") {
           const newTextNode = document.createTextNode(String(newChild));
-          element.insertBefore(newTextNode, oldNode?.nextSibling || null);
+          newTextNode.__wsxManaged = true;
+          if (oldNode && oldNode === targetNode && oldNode.parentNode === element) {
+            element.replaceChild(newTextNode, oldNode);
+          } else {
+            element.insertBefore(newTextNode, targetNode);
+            removeNodeIfNotPreserved(element, oldNode);
+          }
           processedNodes.add(newTextNode);
+          insertionIndex.value++;
         } else if (newChild instanceof DocumentFragment) {
-          element.insertBefore(newChild, oldNode?.nextSibling || null);
+          if (processedNodes) {
+            for (let i2 = 0; i2 < newChild.childNodes.length; i2++) {
+              processedNodes.add(newChild.childNodes[i2]);
+            }
+          }
+          element.insertBefore(newChild, targetNode);
+          removeNodeIfNotPreserved(element, oldNode);
         }
       }
     }
@@ -1298,7 +1288,9 @@ function Fragment(_props, children) {
       return;
     }
     if (typeof child === "string" || typeof child === "number") {
-      fragment.appendChild(document.createTextNode(String(child)));
+      const textNode = document.createTextNode(String(child));
+      textNode.__wsxManaged = true;
+      fragment.appendChild(textNode);
     } else if (child instanceof HTMLElement || child instanceof SVGElement) {
       fragment.appendChild(child);
     } else if (child instanceof DocumentFragment) {

package/dist/jsx.mjs

@@ -1,7 +1,7 @@
 import {
   Fragment,
   h
-} from "./chunk-DYG2LIOG.mjs";
+} from "./chunk-34PNC5CJ.mjs";
 export {
   Fragment,
   h