@wsxjs/wsx-core 0.0.23 → 0.0.24

package/dist/index.mjs

@@ -4,7 +4,7 @@ import {
   createLogger,
   h,
   shouldPreserveElement
-} from "./chunk-ESZYREJK.mjs";
+} from "./chunk-5Q2VEEUH.mjs";
 
 // src/styles/style-manager.ts
 var StyleManager = class {
@@ -401,6 +401,12 @@ var BaseComponent = class extends HTMLElement {
      * @internal
      */
     this._isRendering = false;
+    /**
+     * 已调度渲染标志（防止在同一事件循环中重复注册 requestAnimationFrame）
+     * 用于批量更新：同一事件循环中的多个状态变化只触发一次渲染
+     * @internal
+     */
+    this._hasScheduledRender = false;
     /**
      * 处理 blur 事件，在用户停止输入时执行待处理的重渲染
      * @internal
@@ -507,6 +513,9 @@ var BaseComponent = class extends HTMLElement {
     if (this._isRendering) {
       return;
     }
+    if (this._hasScheduledRender) {
+      return;
+    }
     const root = this.getActiveRoot();
     let activeElement = null;
     if (root instanceof ShadowRoot) {
@@ -532,8 +541,16 @@ var BaseComponent = class extends HTMLElement {
     if (this._pendingRerender) {
       this._pendingRerender = false;
     }
+    this._hasScheduledRender = true;
     requestAnimationFrame(() => {
+      console.warn("[scheduleRerender] RAF callback:", {
+        component: this.constructor.name,
+        connected: this.connected,
+        isRendering: this._isRendering
+      });
+      this._hasScheduledRender = false;
       if (this.connected && !this._isRendering) {
+        console.warn("[scheduleRerender] calling _rerender()");
         this._isRendering = true;
         this._rerender();
       } else if (!this.connected) {
@@ -790,6 +807,7 @@ var WebComponent = class extends BaseComponent {
         (child) => child instanceof HTMLElement && child.style.color === "red" && child.textContent?.includes("Component Error")
       );
       const hasActualContent = allChildren.length > styleElements.length + slotElements.length;
+      this.onConnected?.();
       if (hasActualContent && !hasErrorElement) {
       } else {
         this.shadowRoot.innerHTML = "";
@@ -801,7 +819,6 @@ var WebComponent = class extends BaseComponent {
         this.shadowRoot.appendChild(content);
       }
       this.initializeEventListeners();
-      this.onConnected?.();
       if (hasActualContent === false || hasErrorElement) {
         requestAnimationFrame(() => {
           this.onRendered?.();
@@ -853,8 +870,12 @@ var WebComponent = class extends BaseComponent {
     const focusState = this.captureFocusState();
     this._pendingFocusState = focusState;
     const adoptedStyleSheets = this.shadowRoot.adoptedStyleSheets || [];
+    const hasActualAdoptedStyles = this.shadowRoot.adoptedStyleSheets && this.shadowRoot.adoptedStyleSheets.length > 0;
+    const hasFallbackStyleElement = Array.from(this.shadowRoot.children).some(
+      (child) => child instanceof HTMLStyleElement
+    );
     try {
-      if (adoptedStyleSheets.length === 0) {
+      if (!hasActualAdoptedStyles && !hasFallbackStyleElement) {
         const stylesToApply = this._autoStyles || this.config.styles;
         if (stylesToApply) {
           const styleName = this.config.styleName || this.constructor.name;
@@ -872,31 +893,40 @@ var WebComponent = class extends BaseComponent {
           }
         }
       }
-      if (this.shadowRoot.adoptedStyleSheets) {
-        this.shadowRoot.adoptedStyleSheets = adoptedStyleSheets;
-      }
-      requestAnimationFrame(() => {
+      const isContentAlreadyInShadowRoot = content.parentNode === this.shadowRoot;
+      if (!isContentAlreadyInShadowRoot) {
         this.shadowRoot.appendChild(content);
-        const oldChildren = Array.from(this.shadowRoot.children).filter((child) => {
-          if (child === content) {
-            return false;
-          }
-          if (child instanceof HTMLStyleElement) {
-            return false;
-          }
-          if (shouldPreserveElement(child)) {
-            return false;
-          }
-          return true;
-        });
-        oldChildren.forEach((child) => child.remove());
-        requestAnimationFrame(() => {
-          this.restoreFocusState(focusState);
-          this._pendingFocusState = null;
-          this.onRendered?.();
-          this._isRendering = false;
-        });
+      }
+      const oldChildren = Array.from(this.shadowRoot.children).filter((child) => {
+        if (child === content) {
+          return false;
+        }
+        if (child instanceof HTMLStyleElement) {
+          return false;
+        }
+        if (shouldPreserveElement(child)) {
+          return false;
+        }
+        return true;
       });
+      oldChildren.forEach((child) => child.remove());
+      const hasStylesAfterDOM = this.shadowRoot.adoptedStyleSheets && this.shadowRoot.adoptedStyleSheets.length > 0;
+      const hasStyleElementAfterDOM = Array.from(this.shadowRoot.children).some(
+        (child) => child instanceof HTMLStyleElement
+      );
+      if (adoptedStyleSheets.length > 0) {
+        this.shadowRoot.adoptedStyleSheets = adoptedStyleSheets;
+      } else if (!hasStylesAfterDOM && !hasStyleElementAfterDOM) {
+        const stylesToApply = this._autoStyles || this.config.styles;
+        if (stylesToApply) {
+          const styleName = this.config.styleName || this.constructor.name;
+          StyleManager.applyStyles(this.shadowRoot, styleName, stylesToApply);
+        }
+      }
+      this.restoreFocusState(focusState);
+      this._pendingFocusState = null;
+      this.onRendered?.();
+      this._isRendering = false;
     } catch (error) {
       logger3.error("Error in _rerender:", error);
       this.renderError(error);
@@ -958,6 +988,7 @@ var LightComponent = class extends BaseComponent {
       const hasActualContent = Array.from(this.children).some(
         (child) => child !== styleElement && !(child instanceof HTMLSlotElement)
       );
+      this.onConnected?.();
       if (hasActualContent && !hasErrorElement) {
         this.markJSXChildren();
         if (styleElement && styleElement !== this.firstChild) {
@@ -975,7 +1006,6 @@ var LightComponent = class extends BaseComponent {
         }
       }
       this.initializeEventListeners();
-      this.onConnected?.();
       if (hasActualContent === false || hasErrorElement) {
         requestAnimationFrame(() => {
           this.onRendered?.();
@@ -1074,11 +1104,18 @@ var LightComponent = class extends BaseComponent {
           return true;
         });
         oldChildren.forEach((child) => child.remove());
-        if (stylesToApply && this.children.length > 1) {
-          const styleElement = this.querySelector(
+        if (stylesToApply) {
+          let styleElement = this.querySelector(
             `style[data-wsx-light-component="${styleName}"]`
           );
-          if (styleElement && styleElement !== this.firstChild) {
+          if (!styleElement) {
+            styleElement = document.createElement("style");
+            styleElement.setAttribute("data-wsx-light-component", styleName);
+            styleElement.textContent = stylesToApply;
+            this.insertBefore(styleElement, this.firstChild);
+          } else if (styleElement.textContent !== stylesToApply) {
+            styleElement.textContent = stylesToApply;
+          } else if (styleElement !== this.firstChild) {
             this.insertBefore(styleElement, this.firstChild);
           }
         }

package/dist/jsx-runtime.js

@@ -101,6 +101,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 {
@@ -126,21 +127,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) {
@@ -151,6 +151,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) {
@@ -568,7 +571,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") {
@@ -663,7 +668,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;
@@ -677,13 +682,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) {
@@ -692,29 +707,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);
@@ -736,10 +788,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;
@@ -768,24 +832,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);
     }
   }
@@ -805,6 +884,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") {
@@ -820,6 +905,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") {
@@ -863,7 +955,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") {
@@ -918,12 +1016,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];
@@ -939,9 +1038,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;
@@ -955,7 +1055,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);
@@ -969,30 +1076,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);
         }
@@ -1000,12 +1125,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-runtime.mjs

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