@wsxjs/wsx-core 0.0.30 → 0.1.0

package/dist/jsx-runtime.js

@@ -47,11 +47,6 @@ function isHTMLString(str) {
   const looksLikeMath = /^[^<]*<[^>]*>[^>]*$/.test(trimmed) && !htmlTagPattern.test(trimmed);
   if (looksLikeMath) return false;
   const result = htmlTagPattern.test(trimmed);
-  if (result) {
-    console.log(`[WSX Debug] isHTMLString("${trimmed.substring(0, 50)}..."): ${result}`, {
-      looksLikeMath
-    });
-  }
   return result;
 }
 function flattenChildren(children, skipHTMLDetection = false, depth = 0) {
@@ -77,11 +72,7 @@ function flattenChildren(children, skipHTMLDetection = false, depth = 0) {
           const nodes = parseHTMLToNodes(child);
           if (nodes.length > 0) {
             for (const node of nodes) {
-              if (typeof node === "string") {
-                result.push(node);
-              } else {
-                result.push(node);
-              }
+              result.push(node);
             }
           } else {
             result.push(child);
@@ -95,15 +86,7 @@ function flattenChildren(children, skipHTMLDetection = false, depth = 0) {
       }
     } 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));
-        }
-      }
+      result.push(...flattenChildren(fragmentChildren, skipHTMLDetection, depth + 1));
     } else {
       result.push(child);
     }
@@ -148,6 +131,8 @@ var RenderContext = _RenderContext;
 var INDEX_KEY = "__wsxIndex";
 var componentElementCounters = /* @__PURE__ */ new WeakMap();
 var componentIdCache = /* @__PURE__ */ new WeakMap();
+var instanceAutoIds = /* @__PURE__ */ new WeakMap();
+var globalAutoId = 0;
 function generateCacheKey(tag, props, componentId, component) {
   const userKey = props?.key;
   const index = props?.[INDEX_KEY];
@@ -179,7 +164,13 @@ function getComponentId() {
     if (cachedId) {
       return cachedId;
     }
-    const instanceId = component._instanceId || "default";
+    let instanceId = component._wsxInstanceId;
+    if (instanceId === void 0 || instanceId === null) {
+      if (!instanceAutoIds.has(component)) {
+        instanceAutoIds.set(component, ++globalAutoId);
+      }
+      instanceId = String(instanceAutoIds.get(component));
+    }
     cachedId = `${component.constructor.name}:${instanceId}`;
     componentIdCache.set(component, cachedId);
     return cachedId;
@@ -716,8 +707,8 @@ function findElementNode(oldChild, parent) {
 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;
+    if (node.nodeType === Node.TEXT_NODE && node.__wsxManaged === true && (!processedNodes || !processedNodes.has(node))) {
+      domIndex.value = i;
       return node;
     }
   }
@@ -800,11 +791,6 @@ function replaceOrInsertElementAtPosition(parent, newChild, oldNode, targetNextS
         if (existingNode instanceof HTMLElement || existingNode instanceof SVGElement) {
           const existingCacheKey = getElementCacheKey(existingNode);
           if (!existingCacheKey && existingNode.tagName.toLowerCase() === newChildTag && existingNode.textContent === newChildContent && existingNode !== newChild) {
-            console.log(
-              "[WSX Debug] Found duplicate content, keeping existing:",
-              existingNode.tagName,
-              existingNode.textContent
-            );
             if (processedNodes) processedNodes.add(existingNode);
             return;
           }
@@ -838,35 +824,53 @@ function appendNewChild(parent, child, processedNodes) {
     }
   } else if (child instanceof DocumentFragment) {
     if (processedNodes) {
-      for (let i = 0; i < child.childNodes.length; i++) {
-        processedNodes.add(child.childNodes[i]);
+      const fragmentChildren = Array.from(child.childNodes);
+      for (const fragmentChild of fragmentChildren) {
+        processedNodes.add(fragmentChild);
       }
     }
     parent.appendChild(child);
+  } else if (child instanceof Node) {
+    if (child.parentNode && child.parentNode !== parent) {
+      child.parentNode.removeChild(child);
+    }
+    if (child.parentNode !== parent) {
+      parent.appendChild(child);
+    }
+    if (processedNodes) {
+      processedNodes.add(child);
+    }
   }
 }
-function buildNewChildrenMaps(flatNew) {
+function buildNodeMaps(flatNodes) {
   const elementSet = /* @__PURE__ */ new Set();
   const cacheKeyMap = /* @__PURE__ */ new Map();
-  for (const child of flatNew) {
-    if (child instanceof HTMLElement || child instanceof SVGElement || child instanceof DocumentFragment) {
-      elementSet.add(child);
-      if (child instanceof HTMLElement || child instanceof SVGElement) {
-        const cacheKey = getElementCacheKey(child);
-        if (cacheKey) {
-          cacheKeyMap.set(cacheKey, child);
+  const nodeSet = /* @__PURE__ */ new Set();
+  for (const child of flatNodes) {
+    if (child instanceof Node) {
+      nodeSet.add(child);
+      if (child instanceof HTMLElement || child instanceof SVGElement || child instanceof DocumentFragment) {
+        elementSet.add(child);
+        if (child instanceof HTMLElement || child instanceof SVGElement) {
+          const cacheKey = getElementCacheKey(child);
+          if (cacheKey) {
+            cacheKeyMap.set(cacheKey, child);
+          }
         }
       }
     }
   }
-  return { elementSet, cacheKeyMap };
+  return { elementSet, cacheKeyMap, nodeSet };
 }
-function shouldRemoveNode(node, elementSet, cacheKeyMap, processedNodes) {
+function shouldRemoveNode(node, _elementSet, _cacheKeyMap, processedNodes, nodeSet) {
+  if (processedNodes && processedNodes.has(node)) {
+    return false;
+  }
+  if (nodeSet && nodeSet.has(node)) {
+    return false;
+  }
   if (node.nodeType === Node.TEXT_NODE) {
     if (node.__wsxManaged === true) {
-      if (processedNodes && processedNodes.has(node)) {
-        return false;
-      }
       return true;
     }
     const parent = node.parentNode;
@@ -876,29 +880,10 @@ function shouldRemoveNode(node, elementSet, cacheKeyMap, processedNodes) {
       }
     }
     return true;
-  } else {
-    if (shouldPreserveElement(node)) {
-      return false;
-    }
-  }
-  const isProcessed = processedNodes && processedNodes.has(node);
-  if (isProcessed) {
-    return false;
   }
   if (shouldPreserveElement(node)) {
     return false;
   }
-  if (node instanceof HTMLElement || node instanceof SVGElement || node instanceof DocumentFragment) {
-    if (elementSet.has(node)) {
-      return false;
-    }
-    if (node instanceof HTMLElement || node instanceof SVGElement) {
-      const cacheKey = getElementCacheKey(node);
-      if (cacheKey && cacheKeyMap.has(cacheKey)) {
-        return false;
-      }
-    }
-  }
   return true;
 }
 function deduplicateCacheKeys(parent, cacheKeyMap) {
@@ -925,11 +910,11 @@ function deduplicateCacheKeys(parent, cacheKeyMap) {
     }
   }
 }
-function collectNodesToRemove(parent, elementSet, cacheKeyMap, processedNodes) {
+function collectNodesToRemove(parent, elementSet, cacheKeyMap, processedNodes, nodeSet) {
   const nodesToRemove = [];
   for (let i = 0; i < parent.childNodes.length; i++) {
     const node = parent.childNodes[i];
-    const removed = shouldRemoveNode(node, elementSet, cacheKeyMap, processedNodes);
+    const removed = shouldRemoveNode(node, elementSet, cacheKeyMap, processedNodes, nodeSet);
     if (removed) {
       nodesToRemove.push(node);
     }
@@ -1130,6 +1115,8 @@ function updateChildren(element, oldChildren, newChildren, _cacheManager) {
   const flatOld = flattenChildrenSafe(oldChildren);
   const flatNew = flattenChildrenSafe(newChildren);
   const preservedElements = collectPreservedElements(element);
+  const { cacheKeyMap: oldKeyMap } = buildNodeMaps(flatOld);
+  const newMaps = buildNodeMaps(flatNew);
   const minLength = Math.min(flatOld.length, flatNew.length);
   const domIndex = { value: 0 };
   const insertionIndex = { value: 0 };
@@ -1138,110 +1125,77 @@ function updateChildren(element, oldChildren, newChildren, _cacheManager) {
     const oldChild = flatOld[i];
     const newChild = flatNew[i];
     let oldNode = null;
-    if (oldChild instanceof HTMLElement || oldChild instanceof SVGElement) {
-      oldNode = findElementNode(oldChild, element);
-      if (oldNode && oldNode.parentNode === element) {
-        const nodeIndex = Array.from(element.childNodes).indexOf(oldNode);
-        if (nodeIndex !== -1 && nodeIndex >= domIndex.value) {
-          domIndex.value = nodeIndex + 1;
+    if (newChild instanceof HTMLElement || newChild instanceof SVGElement) {
+      const key = getElementCacheKey(newChild);
+      if (key) {
+        const matchedOld = oldKeyMap.get(key);
+        if (matchedOld && matchedOld.parentNode === element) {
+          oldNode = matchedOld;
         }
       }
-    } else if (typeof oldChild === "string" || typeof oldChild === "number") {
-      if (shouldPreserveElement(element)) {
-        oldNode = null;
-      } else {
+    }
+    if (!oldNode) {
+      if (oldChild instanceof HTMLElement || oldChild instanceof SVGElement) {
+        oldNode = findElementNode(oldChild, element);
+      } else if (typeof oldChild === "string" || typeof oldChild === "number" || oldChild instanceof Node) {
         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 newText = String(newChild);
-        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 {
-        const targetNode = insertionIndex.value < element.childNodes.length ? element.childNodes[insertionIndex.value] : null;
-        if (newChild instanceof HTMLElement || newChild instanceof SVGElement) {
-          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) {
-          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) {
-      if (oldNode && shouldPreserveElement(oldNode)) {
-        continue;
+    if (oldNode && oldNode.parentNode === element) {
+      const childrenArray = Array.from(element.childNodes);
+      const nodeIndex = childrenArray.indexOf(oldNode);
+      if (nodeIndex !== -1 && nodeIndex >= domIndex.value) {
+        domIndex.value = nodeIndex + 1;
       }
-      if (newChild instanceof HTMLElement || newChild instanceof SVGElement) {
-        const insertBeforeNode = insertionIndex.value < element.childNodes.length ? element.childNodes[insertionIndex.value] : null;
-        replaceOrInsertElementAtPosition(
-          element,
-          newChild,
-          oldNode,
-          insertBeforeNode,
-          processedNodes
-        );
+    }
+    const targetNode = insertionIndex.value < element.childNodes.length ? element.childNodes[insertionIndex.value] : null;
+    const isNewTextChild = typeof newChild === "string" || typeof newChild === "number" || newChild instanceof Node && newChild.nodeType === Node.TEXT_NODE;
+    if (isNewTextChild) {
+      const newTextContent = newChild instanceof Node ? newChild.textContent || "" : String(newChild);
+      if (shouldPreserveElement(element)) continue;
+      const targetMatchingNode = newChild instanceof Node ? newChild : oldNode;
+      const updatedNode = updateOrCreateTextNode(
+        element,
+        targetMatchingNode,
+        newTextContent,
+        targetNode
+      );
+      if (updatedNode) {
+        processedNodes.add(updatedNode);
         insertionIndex.value++;
-      } else {
-        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));
-          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) {
-          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 (newChild instanceof HTMLElement || newChild instanceof SVGElement) {
+      replaceOrInsertElementAtPosition(
+        element,
+        newChild,
+        oldNode,
+        targetNode,
+        processedNodes
+      );
+      insertionIndex.value++;
+    } else if (newChild instanceof DocumentFragment) {
+      const fragmentChildren = Array.from(newChild.childNodes);
+      for (const fc of fragmentChildren) {
+        processedNodes.add(fc);
+      }
+      element.insertBefore(newChild, targetNode);
+      if (oldNode && !processedNodes.has(oldNode)) {
+        removeNodeIfNotPreserved(element, oldNode);
+      }
+      insertionIndex.value++;
     }
   }
   for (let i = minLength; i < flatNew.length; i++) {
     appendNewChild(element, flatNew[i], processedNodes);
   }
-  const { elementSet, cacheKeyMap } = buildNewChildrenMaps(flatNew);
-  deduplicateCacheKeys(element, cacheKeyMap);
-  const nodesToRemove = collectNodesToRemove(element, elementSet, cacheKeyMap, processedNodes);
+  deduplicateCacheKeys(element, newMaps.cacheKeyMap);
+  const nodesToRemove = collectNodesToRemove(
+    element,
+    newMaps.elementSet,
+    newMaps.cacheKeyMap,
+    processedNodes,
+    newMaps.nodeSet
+  );
   removeNodes(element, nodesToRemove, _cacheManager);
   reinsertPreservedElements(element, preservedElements);
 }
@@ -1360,6 +1314,8 @@ function Fragment(_props, children) {
       fragment.appendChild(child);
     } else if (child instanceof DocumentFragment) {
       fragment.appendChild(child);
+    } else if (child instanceof Node) {
+      fragment.appendChild(child);
     }
   });
   return fragment;

package/dist/jsx-runtime.mjs

@@ -2,7 +2,7 @@ import {
   Fragment,
   jsx,
   jsxs
-} from "./chunk-2ER76KOQ.mjs";
+} from "./chunk-PNIWQQN6.mjs";
 export {
   Fragment,
   jsx,