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

package/preact/compat/src/index.js

@@ -1,48 +1,49 @@
 import {
-	createElement,
-	render as preactRender,
-	cloneElement as preactCloneElement,
-	createRef,
 	Component,
-	createContext,
 	Fragment,
-	options
+	createContext,
+	createElement,
+	createRef,
+	options,
+	cloneElement as preactCloneElement,
+	render as preactRender
 } from '../..';
 import {
-	useState,
-	useId,
-	useReducer,
+	useCallback,
+	useContext,
+	useDebugValue,
 	useEffect,
-	useLayoutEffect,
-	useRef,
+	useId,
 	useImperativeHandle,
+	useLayoutEffect,
 	useMemo,
-	useCallback,
-	useContext,
-	useDebugValue
+	useReducer,
+	useRef,
+	useState
 } from '../../hooks';
+import { Children } from './Children';
+import { PureComponent } from './PureComponent';
+import { forwardRef } from './forwardRef';
 import {
-	useInsertionEffect,
 	startTransition,
 	useDeferredValue,
-	useSyncExternalStore,
+	useEffectEvent,
+	useInsertionEffect,
 	useTransition
 } from './hooks';
-import { PureComponent } from './PureComponent';
 import { memo } from './memo';
-import { forwardRef } from './forwardRef';
-import { Children } from './Children';
-import { Suspense, lazy } from './suspense';
-import { SuspenseList } from './suspense-list';
 import { createPortal } from './portals';
 import {
+	REACT_ELEMENT_TYPE,
+	__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED,
 	hydrate,
 	render,
-	REACT_ELEMENT_TYPE,
-	__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
+	use,
+	useSyncExternalStore
 } from './render';
+import { Suspense, lazy } from './suspense';
 
-const version = '18.3.1'; // trick libraries to think we are react
+const version = '19.0.0'; // trick libraries to think we are react
 
 /**
  * Legacy version of createElement.
@@ -67,7 +68,7 @@ function isValidElement(element) {
  * @returns {boolean}
  */
 function isFragment(element) {
-	return isValidElement(element) && element.type === Fragment;
+	return isValidElement(element) && element.type == Fragment;
 }
 
 /**
@@ -116,21 +117,12 @@ function unmountComponentAtNode(container) {
 function findDOMNode(component) {
 	return (
 		(component &&
-			(component.base || (component.nodeType === 1 && component))) ||
+			((component._vnode && component._vnode._dom) ||
+				(component.nodeType == 1 && component))) ||
 		null
 	);
 }
 
-/**
- * Deprecated way to control batched rendering inside the reconciler, but we
- * already schedule in batches inside our rendering code
- * @template Arg
- * @param {(arg: Arg) => void} callback function that triggers the updated
- * @param {Arg} [arg] Optional argument that can be passed to the callback
- */
-// eslint-disable-next-line camelcase
-const unstable_batchedUpdates = (callback, arg) => callback(arg);
-
 /**
  * In React, `flushSync` flushes the entire tree and forces a rerender.
  * @template Arg
@@ -141,6 +133,10 @@ const unstable_batchedUpdates = (callback, arg) => callback(arg);
  */
 const flushSync = (callback, arg) => {
 	const prevDebounce = options.debounceRendering;
+
+	// Capture the scheduled render callback so that all updates performed
+	// inside the user callback are batched into a single synchronous commit
+	// instead of every state setter rendering independently.
 	let flush;
 	options.debounceRendering = cb => {
 		flush = cb;
@@ -154,8 +150,18 @@ const flushSync = (callback, arg) => {
 	}
 };
 
-// compat to react-is
-export const isElement = isValidElement;
+/**
+ * In React, `unstable_batchedUpdates` is a legacy feature that was made a no-op
+ * outside of legacy mode in React 18 and a no-op across the board in React 19.
+ * @template Arg
+ * @template Result
+ * @param {(arg: Arg) => Result} callback
+ * @param {Arg} [arg]
+ * @returns {Result}
+ */
+function unstable_batchedUpdates(callback, arg) {
+	return callback(arg);
+}
 
 export * from '../../hooks';
 export {
@@ -172,6 +178,8 @@ export {
 	createRef,
 	Fragment,
 	isValidElement,
+	// compat to react-is
+	isValidElement as isElement,
 	isFragment,
 	isMemo,
 	findDOMNode,
@@ -180,16 +188,16 @@ export {
 	memo,
 	forwardRef,
 	flushSync,
+	unstable_batchedUpdates,
 	useInsertionEffect,
 	startTransition,
 	useDeferredValue,
 	useSyncExternalStore,
 	useTransition,
-	// eslint-disable-next-line camelcase
-	unstable_batchedUpdates,
+	useEffectEvent,
+	use,
 	Fragment as StrictMode,
 	Suspense,
-	SuspenseList,
 	lazy,
 	__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
 };
@@ -205,12 +213,14 @@ export default {
 	useTransition,
 	useDeferredValue,
 	useSyncExternalStore,
+	useEffectEvent,
 	startTransition,
 	useRef,
 	useImperativeHandle,
 	useMemo,
 	useCallback,
 	useContext,
+	use,
 	useDebugValue,
 	version,
 	Children,
@@ -225,7 +235,7 @@ export default {
 	createRef,
 	Fragment,
 	isValidElement,
-	isElement,
+	isElement: isValidElement,
 	isFragment,
 	isMemo,
 	findDOMNode,
@@ -237,7 +247,6 @@ export default {
 	unstable_batchedUpdates,
 	StrictMode: Fragment,
 	Suspense,
-	SuspenseList,
 	lazy,
 	__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
 };

package/preact/compat/src/internal.d.ts

@@ -27,12 +27,11 @@ export interface Component<P = {}, S = {}> extends PreactComponent<P, S> {
 
 export interface FunctionComponent<P = {}> extends PreactFunctionComponent<P> {
 	shouldComponentUpdate?(nextProps: Readonly<P>): boolean;
-	_forwarded?: boolean;
 	_patchedLifecycles?: true;
 }
 
 export interface VNode<T = any> extends PreactVNode<T> {
-	$$typeof?: symbol | string;
+	$$typeof?: symbol;
 	preactCompatNormalized?: boolean;
 }
 

package/preact/compat/src/memo.js

@@ -10,7 +10,7 @@ import { shallowDiffers } from './util';
  */
 export function memo(c, comparer) {
 	function shouldUpdate(nextProps) {
-		let ref = this.props.ref;
+		const ref = this.props.ref;
 		if (ref != nextProps.ref && ref) {
 			typeof ref == 'function' ? ref(null) : (ref.current = null);
 		}
@@ -25,7 +25,7 @@ export function memo(c, comparer) {
 		return createElement(c, props);
 	}
 	Memoed.displayName = 'Memo(' + (c.displayName || c.name) + ')';
-	Memoed._forwarded = Memoed.prototype.isReactComponent = true;
+	Memoed.prototype.isReactComponent = true;
 	Memoed.type = c;
 	return Memoed;
 }

package/preact/compat/src/portals.js

@@ -1,70 +1,4 @@
-import { createElement, render } from '../..';
-
-/**
- * @param {import('../../src/index').RenderableProps<{ context: any }>} props
- */
-function ContextProvider(props) {
-	this.getChildContext = () => props.context;
-	return props.children;
-}
-
-/**
- * Portal component
- * @this {import('./internal').Component}
- * @param {object | null | undefined} props
- *
- * TODO: use createRoot() instead of fake root
- */
-function Portal(props) {
-	const _this = this;
-	let container = props._container;
-
-	_this.componentWillUnmount = function () {
-		render(null, _this._temp);
-		_this._temp = null;
-		_this._container = null;
-	};
-
-	// When we change container we should clear our old container and
-	// indicate a new mount.
-	if (_this._container && _this._container !== container) {
-		_this.componentWillUnmount();
-	}
-
-	if (!_this._temp) {
-		// Ensure the element has a mask for useId invocations
-		let root = _this._vnode;
-		while (root !== null && !root._mask && root._parent !== null) {
-			root = root._parent;
-		}
-
-		_this._container = container;
-
-		// Create a fake DOM parent node that manages a subset of `container`'s children:
-		_this._temp = {
-			nodeType: 1,
-			parentNode: container,
-			childNodes: [],
-			_children: { _mask: root._mask },
-			contains: () => true,
-			namespaceURI: container.namespaceURI,
-			insertBefore(child, before) {
-				this.childNodes.push(child);
-				_this._container.insertBefore(child, before);
-			},
-			removeChild(child) {
-				this.childNodes.splice(this.childNodes.indexOf(child) >>> 1, 1);
-				_this._container.removeChild(child);
-			}
-		};
-	}
-
-	// Render our wrapping element into temp.
-	render(
-		createElement(ContextProvider, { context: _this.context }, props._vnode),
-		_this._temp
-	);
-}
+import { createPortal as corePortal } from '../..';
 
 /**
  * Create a `Portal` to continue rendering the vnode tree at a different DOM node
@@ -72,7 +6,7 @@ function Portal(props) {
  * @param {import('./internal').PreactElement} container The DOM node to continue rendering in to.
  */
 export function createPortal(vnode, container) {
-	const el = createElement(Portal, { _vnode: vnode, _container: container });
+	const el = corePortal(vnode, container);
 	el.containerInfo = container;
 	return el;
 }

package/preact/compat/src/render.js

@@ -18,31 +18,75 @@ import {
 	useRef,
 	useState
 } from '../../hooks';
-import {
-	useDeferredValue,
-	useInsertionEffect,
-	useSyncExternalStore,
-	useTransition
-} from './index';
+import { useDeferredValue, useInsertionEffect, useTransition } from './index';
+import { assign, IS_NON_DIMENSIONAL } from './util';
+
+export const REACT_ELEMENT_TYPE = Symbol.for('react.element');
 
-export const REACT_ELEMENT_TYPE =
-	(typeof Symbol != 'undefined' && Symbol.for && Symbol.for('react.element')) ||
-	0xeac7;
+const MODE_HYDRATE = 1 << 5;
+let currentComponent, hydrationRoot, renderTrackingInitialized;
 
 const CAMEL_PROPS =
-	/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/;
-const ON_ANI = /^on(Ani|Tra|Tou|BeforeInp|Compo)/;
+	/^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|dominant|fill|flood|font|glyph(?!R)|horiz|image(?!S)|letter|lighting|marker(?!H|W|U)|overline|paint|pointer|shape|stop|strikethrough|stroke|text(?!L)|transform|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/;
 const CAMEL_REPLACE = /[A-Z0-9]/g;
-const IS_DOM = typeof document !== 'undefined';
+const IS_DOM = typeof document < 'u';
+
+/**
+ * This is taken from https://github.com/facebook/react/blob/main/packages/use-sync-external-store/src/useSyncExternalStoreShimClient.js#L84
+ * on a high level this cuts out the warnings, ... and attempts a smaller implementation
+ * @typedef {{ _value: any; _getSnapshot: () => any }} Store
+ */
+export const useSyncExternalStore = /* @__PURE__ */ initRenderTracking(
+	function useSyncExternalStore(subscribe, getSnapshot, getServerSnapshot) {
+		const serverRendering = options._skipEffects || hydrationRoot;
+		const value = serverRendering
+			? (getServerSnapshot || getSnapshot)()
+			: getSnapshot();
+
+		/**
+		 * @typedef {{ _instance: Store }} StoreRef
+		 * @type {[StoreRef, (store: StoreRef) => void]}
+		 */
+		const [{ _instance }, forceUpdate] = useState({
+			_instance: { _value: value, _getSnapshot: getSnapshot }
+		});
+
+		useLayoutEffect(() => {
+			_instance._value = value;
+			_instance._getSnapshot = getSnapshot;
+
+			if (didSnapshotChange(_instance)) {
+				forceUpdate({ _instance });
+			}
+		}, [subscribe, value, getSnapshot]);
+
+		useEffect(() => {
+			if (didSnapshotChange(_instance)) {
+				forceUpdate({ _instance });
+			}
+
+			return subscribe(() => {
+				if (didSnapshotChange(_instance)) {
+					forceUpdate({ _instance });
+				}
+			});
+		}, [subscribe]);
+
+		return value;
+	}
+);
+
+/** @type {(inst: Store) => boolean} */
+function didSnapshotChange(inst) {
+	try {
+		return !Object.is(inst._value, inst._getSnapshot());
+	} catch (error) {
+		return true;
+	}
+}
 
 // Input types for which onchange should not be converted to oninput.
-// type="file|checkbox|radio", plus "range" in IE11.
-// (IE11 doesn't support Symbol, which we use here to turn `rad` into `ra` which matches "range")
-const onChangeInputType = type =>
-	(typeof Symbol != 'undefined' && typeof Symbol() == 'symbol'
-		? /fil|che|rad/
-		: /fil|che|ra/
-	).test(type);
+const onChangeInputType = type => /fil|che|rad/.test(type);
 
 // Some libraries like `react-virtualized` explicitly check for this.
 Component.prototype.isReactComponent = true;
@@ -132,46 +176,63 @@ function handleDomVNode(vnode) {
 		let value = props[i];
 
 		if (
-			(i === 'value' && 'defaultValue' in props && value == null) ||
+			(i == 'value' && 'defaultValue' in props && value == null) ||
 			// Emulate React's behavior of not rendering the contents of noscript tags on the client.
-			(IS_DOM && i === 'children' && type === 'noscript') ||
-			i === 'class' ||
-			i === 'className'
+			(IS_DOM && i == 'children' && type == 'noscript') ||
+			i == 'class' ||
+			i == 'className'
 		) {
 			// Skip applying value if it is null/undefined and we already set
 			// a default value
 			continue;
 		}
 
-		let lowerCased = i.toLowerCase();
-		if (i === 'defaultValue' && 'value' in props && props.value == null) {
+		if (i == 'style' && typeof value == 'object') {
+			let cloned;
+			for (let key in value) {
+				if (typeof value[key] == 'number' && !IS_NON_DIMENSIONAL.test(key)) {
+					if (!cloned) {
+						cloned = value = assign({}, value);
+					}
+					value[key] += 'px';
+				}
+			}
+		} else if (i == 'defaultValue' && 'value' in props && props.value == null) {
 			// `defaultValue` is treated as a fallback `value` when a value prop is present but null/undefined.
 			// `defaultValue` for Elements with no value prop is the same as the DOM defaultValue property.
 			i = 'value';
-		} else if (i === 'download' && value === true) {
+		} else if (i == 'download' && value === true) {
 			// Calling `setAttribute` with a truthy value will lead to it being
 			// passed as a stringified value, e.g. `download="true"`. React
 			// converts it to an empty string instead, otherwise the attribute
 			// value will be used as the file name and the file will be called
 			// "true" upon downloading it.
 			value = '';
-		} else if (lowerCased === 'translate' && value === 'no') {
+		} else if (i == 'translate' && value === 'no') {
 			value = false;
-		} else if (lowerCased[0] === 'o' && lowerCased[1] === 'n') {
-			if (lowerCased === 'ondoubleclick') {
+		} else if (i[0] == 'o' && i[1] == 'n') {
+			let lowerCased = i.toLowerCase();
+			if (lowerCased == 'ondoubleclick') {
 				i = 'ondblclick';
 			} else if (
-				lowerCased === 'onchange' &&
-				(type === 'input' || type === 'textarea') &&
+				lowerCased == 'onchange' &&
+				(type == 'input' || type == 'textarea') &&
 				!onChangeInputType(props.type)
 			) {
 				lowerCased = i = 'oninput';
-			} else if (lowerCased === 'onfocus') {
+			} else if (lowerCased == 'onfocus') {
 				i = 'onfocusin';
-			} else if (lowerCased === 'onblur') {
+			} else if (lowerCased == 'onblur') {
 				i = 'onfocusout';
-			} else if (ON_ANI.test(i)) {
+			}
+
+			// Add support for onInput and onChange, see #3561
+			// if we have an oninput prop already change it to oninputCapture
+			if (lowerCased == 'oninput') {
 				i = lowerCased;
+				if (normalizedProps[i]) {
+					i = 'oninputCapture';
+				}
 			}
 		} else if (isNonDashedType && CAMEL_PROPS.test(i)) {
 			i = i.replace(CAMEL_REPLACE, '-$&').toLowerCase();
@@ -179,15 +240,6 @@ function handleDomVNode(vnode) {
 			value = undefined;
 		}
 
-		// Add support for onInput and onChange, see #3561
-		// if we have an oninput prop already change it to oninputCapture
-		if (lowerCased === 'oninput') {
-			i = lowerCased;
-			if (normalizedProps[i]) {
-				i = 'oninputCapture';
-			}
-		}
-
 		normalizedProps[i] = value;
 	}
 
@@ -232,55 +284,112 @@ function handleDomVNode(vnode) {
 let oldVNodeHook = options.vnode;
 options.vnode = vnode => {
 	// only normalize props on Element nodes
-	if (typeof vnode.type === 'string') {
+	if (typeof vnode.type == 'string') {
 		handleDomVNode(vnode);
+	} else if (typeof vnode.type == 'function') {
+		const shouldApplyRef =
+			'prototype' in vnode.type && vnode.type.prototype.render;
+		if ('ref' in vnode.props && shouldApplyRef) {
+			vnode.ref = vnode.props.ref;
+			delete vnode.props.ref;
+		}
+
+		if (vnode.type.defaultProps) {
+			let normalizedProps = assign({}, vnode.props);
+			for (let i in vnode.type.defaultProps) {
+				if (normalizedProps[i] === undefined) {
+					normalizedProps[i] = vnode.type.defaultProps[i];
+				}
+			}
+			vnode.props = normalizedProps;
+		}
 	}
 
+	// React 19 keeps `ref` in element.props for every element type, and that's
+	// where libraries detecting React 19 read it (e.g. MUI's getReactElementRef).
+	// DOM and class vnodes keep theirs on vnode.ref.
+	if (vnode.ref && !('ref' in vnode.props)) {
+		Object.defineProperty(vnode.props, 'ref', {
+			value: vnode.ref,
+			configurable: true,
+			writable: true
+		});
+	}
 	vnode.$$typeof = REACT_ELEMENT_TYPE;
 
 	if (oldVNodeHook) oldVNodeHook(vnode);
 };
 
-// Only needed for react-relay
-let currentComponent;
-const oldBeforeRender = options._render;
-options._render = function (vnode) {
-	if (oldBeforeRender) {
-		oldBeforeRender(vnode);
-	}
-	currentComponent = vnode._component;
-};
-
-const oldDiffed = options.diffed;
-/** @type {(vnode: import('./internal').VNode) => void} */
-options.diffed = function (vnode) {
-	if (oldDiffed) {
-		oldDiffed(vnode);
+// Only needed for react-relay and useSyncExternalStore hydration.
+function initRenderTracking(value) {
+	if (!renderTrackingInitialized) {
+		renderTrackingInitialized = true;
+
+		const oldBeforeRender = options._render;
+		options._render = vnode => {
+			if (oldBeforeRender) oldBeforeRender(vnode);
+			if (vnode._flags & MODE_HYDRATE) hydrationRoot = vnode;
+			currentComponent = vnode._component;
+		};
+
+		const oldDiffed = options.diffed;
+		options.diffed = vnode => {
+			if (oldDiffed) oldDiffed(vnode);
+			currentComponent = null;
+			if (hydrationRoot == vnode) hydrationRoot = null;
+		};
 	}
 
-	const props = vnode.props;
-	const dom = vnode._dom;
+	return value;
+}
 
-	if (
-		dom != null &&
-		vnode.type === 'textarea' &&
-		'value' in props &&
-		props.value !== dom.value
-	) {
-		dom.value = props.value == null ? '' : props.value;
+/**
+ * Read the value of a Promise (suspending while pending) or a Context.
+ * Unlike other hooks, `use` may be called conditionally.
+ * @template T
+ * @param {(Promise<T> & { status?: string, value?: T, reason?: any }) | import('../../src/internal').PreactContext} resource
+ * @returns {T}
+ */
+export const use = /* @__PURE__ */ initRenderTracking(function use(resource) {
+	// A Context is a function without a `then`, a thenable has one.
+	if (resource.then) {
+		if (resource.status == 'fulfilled') return resource.value;
+		if (resource.status == 'rejected') throw resource.reason;
+		if (!resource.status) {
+			resource.status = 'pending';
+			resource.then(
+				value => {
+					resource.status = 'fulfilled';
+					resource.value = value;
+				},
+				reason => {
+					resource.status = 'rejected';
+					resource.reason = reason;
+				}
+			);
+		}
+		throw resource;
 	}
 
-	currentComponent = null;
-};
+	const id = resource._id;
+	const provider = currentComponent._globalContext[id];
+	if (!provider) return resource._defaultValue;
+	// `use` runs on every render without hook state, while `provider.sub`
+	// wraps `componentWillUnmount` on each call — mark the component so we
+	// only subscribe it once.
+	if (!currentComponent[id]) {
+		currentComponent[id] = true;
+		provider.sub(currentComponent);
+	}
+	return provider.props.value;
+});
 
 // This is a very very private internal function for React it
 // is used to sort-of do runtime dependency injection.
 export const __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = {
 	ReactCurrentDispatcher: {
 		current: {
-			readContext(context) {
-				return currentComponent._globalContext[context._id].props.value;
-			},
+			readContext: use,
 			useCallback,
 			useContext,
 			useDebugValue,

package/preact/compat/src/suspense.d.ts

@@ -1,6 +1,4 @@
-// Intentionally not using a relative path to take advantage of
-// the TS version resolution mechanism
-import { Component, ComponentChild, ComponentChildren } from 'preact';
+import { Component, ComponentChild, ComponentChildren } from '../../src/index';
 
 //
 // Suspense/lazy