@kunpeng-js/properties-panel 2026.0.0-alpha2 → 2026.10.2

package/preact/src/create-portal.js

@@ -0,0 +1,20 @@
+import { createVNode } from './create-element';
+
+/**
+ * Portal component. A unique type is used instead of Fragment so that a
+ * portal returned directly from a component isn't collapsed into the
+ * component's children array by the Fragment unwrapping in `diff()`.
+ * @param {object} props
+ */
+function Portal(props) {
+	return props.children;
+}
+
+/**
+ * Create a `Portal` to continue rendering the vnode tree at a different DOM node
+ * @param {import('./internal').ComponentChildren} vnode The vnode to render
+ * @param {import('./internal').PreactElement} container The DOM node to continue rendering in to
+ */
+export function createPortal(vnode, container) {
+	return createVNode(Portal, { _parentDom: container, children: vnode });
+}

package/preact/src/diff/catch-error.js

@@ -1,4 +1,10 @@
-import { NULL } from '../constants';
+import { resetRenderCount } from '../component';
+import {
+	COMPONENT_DIRTY,
+	COMPONENT_PENDING_ERROR,
+	COMPONENT_PROCESSING_EXCEPTION,
+	COMPONENT_FORCE
+} from '../constants';
 
 /**
  * Find the closest error boundary to a thrown error and call it
@@ -14,33 +20,45 @@ export function _catchError(error, vnode, oldVNode, errorInfo) {
 	let component,
 		/** @type {import('../internal').ComponentType} */
 		ctor,
-		/** @type {boolean} */
+		/** @type {number} */
 		handled;
 
 	for (; (vnode = vnode._parent); ) {
-		if ((component = vnode._component) && !component._processingException) {
+		if (
+			(component = vnode._component) &&
+			!(component._bits & COMPONENT_PROCESSING_EXCEPTION)
+		) {
+			component._bits |= COMPONENT_FORCE;
 			try {
 				ctor = component.constructor;
 
-				if (ctor && ctor.getDerivedStateFromError != NULL) {
+				if (ctor && ctor.getDerivedStateFromError) {
 					component.setState(ctor.getDerivedStateFromError(error));
-					handled = component._dirty;
+					handled = component._bits & COMPONENT_DIRTY;
 				}
 
-				if (component.componentDidCatch != NULL) {
+				if (component.componentDidCatch) {
 					component.componentDidCatch(error, errorInfo || {});
-					handled = component._dirty;
+					handled = component._bits & COMPONENT_DIRTY;
 				}
 
 				// This is an error boundary. Mark it as having bailed out, and whether it was mid-hydration.
 				if (handled) {
-					return (component._pendingError = component);
+					component._bits |= COMPONENT_PENDING_ERROR;
+					return;
 				}
 			} catch (e) {
 				error = e;
+				// This component failed to handle the error, so what its
+				// getDerivedStateFromError did must not make the next ancestor a
+				// boundary.
+				handled = 0;
 			}
 		}
 	}
 
+	// Reset rerender count to 0, so that the next render will not be skipped
+	// when we leverage prefresh
+	resetRenderCount();
 	throw error;
 }

package/preact/src/diff/children.js

@@ -5,6 +5,7 @@ import {
 	EMPTY_ARR,
 	INSERT_VNODE,
 	MATCHED,
+	REF_DETACHED,
 	UNDEFINED,
 	NULL
 } from '../constants';
@@ -39,6 +40,7 @@ import { getDomSibling } from '../component';
  * siblings. In most cases, it starts out as `oldChildren[0]._dom`.
  * @param {boolean} isHydrating Whether or not we are in hydration
  * @param {any[]} refQueue an array of elements needed to invoke refs
+ * @returns {PreactElement} The next sibling DOM element to insert new elements
  */
 export function diffChildren(
 	parentDom,
@@ -63,10 +65,11 @@ export function diffChildren(
 		/** @type {PreactElement} */
 		firstChildDom;
 
-	// This is a compression of oldParentVNode!=null && oldParentVNode != EMPTY_OBJ && oldParentVNode._children || EMPTY_ARR
-	// as EMPTY_OBJ._children should be `undefined`.
+	// This is a compression of oldParentVNode != EMPTY_OBJ && oldParentVNode._children || EMPTY_ARR
+	// as EMPTY_OBJ._children should be `undefined`. Callers always pass at
+	// least EMPTY_OBJ, so a null check isn't needed.
 	/** @type {VNode[]} */
-	let oldChildren = (oldParentVNode && oldParentVNode._children) || EMPTY_ARR;
+	let oldChildren = oldParentVNode._children || EMPTY_ARR;
 
 	let newChildrenLength = renderResult.length;
 
@@ -84,8 +87,10 @@ export function diffChildren(
 
 		// At this point, constructNewChildrenArray has assigned _index to be the
 		// matchingIndex for this VNode's oldVNode (or -1 if there is no oldVNode).
+		// ~_index guards the -1 case: a negative array index is a named property
+		// access which V8 can't serve from the fast elements path.
 		oldVNode =
-			(childVNode._index != -1 && oldChildren[childVNode._index]) || EMPTY_OBJ;
+			(~childVNode._index && oldChildren[childVNode._index]) || EMPTY_OBJ;
 
 		// Update childVNode._index to its final index
 		childVNode._index = i;
@@ -106,23 +111,23 @@ export function diffChildren(
 
 		// Adjust DOM nodes
 		newDom = childVNode._dom;
-		if (childVNode.ref && oldVNode.ref != childVNode.ref) {
-			if (oldVNode.ref) {
-				applyRef(oldVNode.ref, NULL, childVNode);
+		// A ref detached while its subtree was parked by Suspense is attached
+		// again on reveal.
+		if (oldVNode.ref != childVNode.ref || oldVNode._flags & REF_DETACHED) {
+			if (oldVNode.ref) applyRef(oldVNode.ref, NULL, childVNode, oldVNode);
+			if (childVNode.ref) {
+				refQueue.push(
+					childVNode.ref,
+					childVNode._component || newDom,
+					childVNode
+				);
 			}
-			refQueue.push(
-				childVNode.ref,
-				childVNode._component || newDom,
-				childVNode
-			);
 		}
 
-		if (firstChildDom == NULL && newDom != NULL) {
-			firstChildDom = newDom;
-		}
+		firstChildDom = firstChildDom || newDom;
 
 		if (childVNode._flags & INSERT_VNODE) {
-			oldDom = insert(childVNode, oldDom, parentDom);
+			oldDom = insert(childVNode, oldDom, parentDom, !oldVNode._original);
 
 			// When a matched VNode is physically moved via INSERT_VNODE, its old
 			// _dom pointer becomes a stale positional reference. Clear it so that
@@ -170,7 +175,14 @@ function constructNewChildrenArray(
 
 	let skew = 0;
 
-	newParentVNode._children = new Array(newChildrenLength);
+	/** Whether any matched child was found far from its skewed index, i.e. a
+	 * real reorder happened and we need to compute the minimal set of moves. */
+	let moved = false;
+
+	// Hoisted: every normalization branch below writes through this array, so
+	// reading `_children` off the vnode each time is a wasted property load.
+	/** @type {VNode[]} */
+	let newChildren = (newParentVNode._children = Array(newChildrenLength));
 	for (i = 0; i < newChildrenLength; i++) {
 		// @ts-expect-error We are reusing the childVNode variable to hold both the
 		// pre and post normalized childVNode
@@ -181,48 +193,38 @@ function constructNewChildrenArray(
 			typeof childVNode == 'boolean' ||
 			typeof childVNode == 'function'
 		) {
-			newParentVNode._children[i] = NULL;
+			newChildren[i] = NULL;
 			continue;
 		}
 		// If this newVNode is being reused (e.g. <div>{reuse}{reuse}</div>) in the same diff,
 		// or we are rendering a component (e.g. setState) copy the oldVNodes so it can have
 		// it's own DOM & etc. pointers
+		// Anything that isn't an object at this point is a string, number or
+		// bigint (null, booleans and functions are handled above), String
+		// objects are the lone object type rendered as text.
 		else if (
-			typeof childVNode == 'string' ||
-			typeof childVNode == 'number' ||
-			// eslint-disable-next-line valid-typeof
-			typeof childVNode == 'bigint' ||
+			typeof childVNode != 'object' ||
 			childVNode.constructor == String
 		) {
-			childVNode = newParentVNode._children[i] = createVNode(
-				NULL,
-				childVNode,
-				NULL,
-				NULL,
-				NULL
-			);
+			childVNode = newChildren[i] = createVNode(NULL, childVNode);
 		} else if (isArray(childVNode)) {
-			childVNode = newParentVNode._children[i] = createVNode(
-				Fragment,
-				{ children: childVNode },
-				NULL,
-				NULL,
-				NULL
-			);
-		} else if (childVNode.constructor === UNDEFINED && childVNode._depth > 0) {
+			childVNode = newChildren[i] = createVNode(Fragment, {
+				children: childVNode
+			});
+		} else if (childVNode.constructor === UNDEFINED && childVNode._depth) {
 			// VNode is already in use, clone it. This can happen in the following
 			// scenario:
 			//   const reuse = <div />
 			//   <div>{reuse}<span />{reuse}</div>
-			childVNode = newParentVNode._children[i] = createVNode(
+			childVNode = newChildren[i] = createVNode(
 				childVNode.type,
 				childVNode.props,
 				childVNode.key,
-				childVNode.ref ? childVNode.ref : NULL,
+				childVNode.ref,
 				childVNode._original
 			);
 		} else {
-			newParentVNode._children[i] = childVNode;
+			newChildren[i] = childVNode;
 		}
 
 		const skewedIndex = i + skew;
@@ -240,7 +242,8 @@ function constructNewChildrenArray(
 		));
 
 		oldVNode = NULL;
-		if (matchingIndex != -1) {
+		// ~matchingIndex is only falsy for -1, i.e. when no match was found
+		if (~matchingIndex) {
 			oldVNode = oldChildren[matchingIndex];
 			remainingOldChildren--;
 			if (oldVNode) {
@@ -251,10 +254,8 @@ function constructNewChildrenArray(
 		// Here, we define isMounting for the purposes of the skew diffing
 		// algorithm. Nodes that are unsuspending are considered mounting and we detect
 		// this by checking if oldVNode._original == null
-		const isMounting = oldVNode == NULL || oldVNode._original == NULL;
-
-		if (isMounting) {
-			if (matchingIndex == -1) {
+		if (!oldVNode || !oldVNode._original) {
+			if (!~matchingIndex) {
 				// When the array of children is growing we need to decrease the skew
 				// as we are adding a new element to the array.
 				// Example:
@@ -280,38 +281,74 @@ function constructNewChildrenArray(
 			if (typeof childVNode.type != 'function') {
 				childVNode._flags |= INSERT_VNODE;
 			}
-		} else if (matchingIndex != skewedIndex) {
-			// When we move elements around i.e. [0, 1, 2] --> [1, 0, 2]
-			// --> we diff 1, we find it at position 1 while our skewed index is 0 and our skew is 0
-			//     we set the skew to 1 as we found an offset.
-			// --> we diff 0, we find it at position 0 while our skewed index is at 2 and our skew is 1
-			//     this makes us increase the skew again.
-			// --> we diff 2, we find it at position 2 while our skewed index is at 4 and our skew is 2
-			//
-			// this becomes an optimization question where currently we see a 1 element offset as an insertion
-			// or deletion i.e. we optimize for [0, 1, 2] --> [9, 0, 1, 2]
-			// while a more than 1 offset we see as a swap.
-			// We could probably build heuristics for having an optimized course of action here as well, but
-			// might go at the cost of some bytes.
-			//
-			// If we wanted to optimize for i.e. only swaps we'd just do the last two code-branches and have
-			// only the first item be a re-scouting and all the others fall in their skewed counter-part.
-			// We could also further optimize for swaps
+		} else {
+			// Matched children are candidates for the minimal-move pass below;
+			// MATCHED on a _new_ vnode is cleared in diffChildren's placement loop.
+			childVNode._flags |= MATCHED;
+
+			// The skew adjustments keep findMatchingIndex's search centered for
+			// shift patterns (insertions/removals at the front). A match further
+			// than one position away means children were genuinely reordered:
+			// flag it so the minimal set of moves is computed below. Off-by-one
+			// matches provably keep matched old indices in increasing order, so
+			// no moves are needed for them.
 			if (matchingIndex == skewedIndex - 1) {
 				skew--;
 			} else if (matchingIndex == skewedIndex + 1) {
 				skew++;
-			} else {
+			} else if (matchingIndex != skewedIndex) {
 				if (matchingIndex > skewedIndex) {
 					skew--;
 				} else {
 					skew++;
 				}
 
-				// Move this VNode's DOM if the original index (matchingIndex) doesn't
-				// match the new skew index (i + new skew)
-				// In the former two branches we know that it matches after skewing
-				childVNode._flags |= INSERT_VNODE;
+				moved = true;
+			}
+		}
+	}
+
+	if (moved) {
+		// Children were reordered: mark the minimal set of matched (MATCHED flag)
+		// children for insertion by finding the longest increasing subsequence of
+		// old indices (patience sorting). Children on the subsequence stay in
+		// place, all others get INSERT_VNODE. `_index` still holds the
+		// matchingIndex here.
+		/** @type {number[]} tails[x] is the smallest old index ending an increasing subsequence of length x+1 */
+		let tails = [];
+		/** @type {number[]} length of the longest increasing subsequence ending at child i */
+		let lisLengths = [];
+		for (i = 0; i < newChildrenLength; i++) {
+			childVNode = newChildren[i];
+			if (childVNode && childVNode._flags & MATCHED) {
+				// Binary search for the insertion point, keeping the pass at
+				// O(n log n) even for pathological reorders.
+				let lo = 0,
+					hi = tails.length;
+				while (lo < hi) {
+					const mid = (lo + hi) >> 1;
+					if (tails[mid] < childVNode._index) {
+						lo = mid + 1;
+					} else {
+						hi = mid;
+					}
+				}
+				tails[lo] = childVNode._index;
+				lisLengths[i] = lo + 1;
+			}
+		}
+
+		// `skew` is dead after the main loop; reuse it as the remaining
+		// subsequence length while walking backwards. Likewise `i` is left at
+		// newChildrenLength by the loop above.
+		skew = tails.length;
+		while (i--) {
+			if (lisLengths[i]) {
+				if (lisLengths[i] == skew) {
+					skew--;
+				} else {
+					newChildren[i]._flags |= INSERT_VNODE;
+				}
 			}
 		}
 	}
@@ -319,11 +356,12 @@ function constructNewChildrenArray(
 	// Remove remaining oldChildren if there are any. Loop forwards so that as we
 	// unmount DOM from the beginning of the oldChildren, we can adjust oldDom to
 	// point to the next child, which needs to be the first DOM node that won't be
-	// unmounted.
+	// unmounted. Keep this a plain loop: an arrow function here would capture
+	// `oldDom`, forcing V8 to context-allocate it on every call to this function.
 	if (remainingOldChildren) {
 		for (i = 0; i < oldChildrenLength; i++) {
 			oldVNode = oldChildren[i];
-			if (oldVNode != NULL && (oldVNode._flags & MATCHED) == 0) {
+			if (oldVNode && !(oldVNode._flags & MATCHED)) {
 				if (oldVNode._dom == oldDom) {
 					oldDom = getDomSibling(oldVNode);
 				}
@@ -340,35 +378,56 @@ function constructNewChildrenArray(
  * @param {VNode} parentVNode
  * @param {PreactElement} oldDom
  * @param {PreactElement} parentDom
+ * @param {boolean} isMounting
  * @returns {PreactElement}
  */
-function insert(parentVNode, oldDom, parentDom) {
+function insert(parentVNode, oldDom, parentDom, isMounting) {
 	// Note: VNodes in nested suspended trees may be missing _children.
-
 	if (typeof parentVNode.type == 'function') {
+		// Root children live in another container, they never move with the
+		// host tree and contribute nothing to the host insertion cursor.
+		if (parentVNode.props._parentDom) return oldDom;
 		let children = parentVNode._children;
-		for (let i = 0; children && i < children.length; i++) {
-			if (children[i]) {
-				// If we enter this code path on sCU bailout, where we copy
-				// oldVNode._children to newVNode._children, we need to update the old
-				// children's _parent pointer to point to the newVNode (parentVNode
-				// here).
-				children[i]._parent = parentVNode;
-				oldDom = insert(children[i], oldDom, parentDom);
+		if (children) {
+			for (let i = 0; i < children.length; i++) {
+				if (children[i]) {
+					// If we enter this code path on sCU bailout, where we copy
+					// oldVNode._children to newVNode._children, we need to update the old
+					// children's _parent pointer to point to the newVNode (parentVNode
+					// here).
+					children[i]._parent = parentVNode;
+					oldDom = insert(children[i], oldDom, parentDom, false);
+				}
 			}
 		}
 
 		return oldDom;
-	} else if (parentVNode._dom != oldDom) {
-		if (oldDom && parentVNode.type && !oldDom.parentNode) {
+	} else {
+		// A cursor a parked Suspense subtree detached can't be a reference node:
+		// retry from the vnode tree, then give up and append.
+		if (oldDom && !oldDom.parentNode) {
 			oldDom = getDomSibling(parentVNode);
+			if (oldDom && !oldDom.parentNode) oldDom = NULL;
 		}
-		oldDom = parentDom.insertBefore(parentVNode._dom, oldDom || NULL);
+
+		// Comments (e.g. server `$s` markers) are never ours: a node right after
+		// them is already in place.
+		let next = oldDom;
+		while (next && next.nodeType == 8) next = next.nextSibling;
+
+		if (parentVNode._dom != next) {
+			// Containers that aren't DOM nodes may not implement moveBefore()
+			if (!isMounting && parentDom.moveBefore && parentVNode._dom.parentNode) {
+				// @ts-expect-error This isn't added to TypeScript lib.d.ts yet
+				parentDom.moveBefore(parentVNode._dom, oldDom);
+			} else {
+				parentDom.insertBefore(parentVNode._dom, oldDom || NULL);
+			}
+		}
+		oldDom = parentVNode._dom;
 	}
 
-	do {
-		oldDom = oldDom && oldDom.nextSibling;
-	} while (oldDom != NULL && oldDom.nodeType == 8);
+	while ((oldDom = oldDom && oldDom.nextSibling) && oldDom.nodeType == 8);
 
 	return oldDom;
 }
@@ -381,13 +440,14 @@ function insert(parentVNode, oldDom, parentDom) {
  */
 export function toChildArray(children, out) {
 	out = out || [];
-	if (children == NULL || typeof children == 'boolean') {
-	} else if (isArray(children)) {
-		children.some(child => {
-			toChildArray(child, out);
-		});
-	} else {
-		out.push(children);
+	if (children != NULL && typeof children != 'boolean') {
+		if (isArray(children)) {
+			children.some(child => {
+				toChildArray(child, out);
+			});
+		} else {
+			out.push(children);
+		}
 	}
 	return out;
 }
@@ -408,7 +468,7 @@ function findMatchingIndex(
 	const key = childVNode.key;
 	const type = childVNode.type;
 	let oldVNode = oldChildren[skewedIndex];
-	const matched = oldVNode != NULL && (oldVNode._flags & MATCHED) == 0;
+	const matched = oldVNode && !(oldVNode._flags & MATCHED);
 
 	// We only need to perform a search if there are more children
 	// (remainingOldChildren) to search. However, if the oldVNode we just looked
@@ -423,10 +483,12 @@ function findMatchingIndex(
 	// we should not search as we risk re-using state of an unrelated VNode. (reverted for now)
 	let shouldSearch =
 		// (typeof type != 'function' || type === Fragment || key) &&
+		// The ternary keeps this a Smi comparison; `> matched` would compare
+		// number to boolean which V8 can't serve from the fast path.
 		remainingOldChildren > (matched ? 1 : 0);
 
 	if (
-		(oldVNode === NULL && key == null) ||
+		(oldVNode === NULL && key == NULL) ||
 		(matched && key == oldVNode.key && type == oldVNode.type)
 	) {
 		return skewedIndex;
@@ -437,8 +499,8 @@ function findMatchingIndex(
 			const childIndex = x >= 0 ? x-- : y++;
 			oldVNode = oldChildren[childIndex];
 			if (
-				oldVNode != NULL &&
-				(oldVNode._flags & MATCHED) == 0 &&
+				oldVNode &&
+				!(oldVNode._flags & MATCHED) &&
 				key == oldVNode.key &&
 				type == oldVNode.type
 			) {