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

package/preact/src/index.d.ts

@@ -39,9 +39,9 @@ export interface VNode<P = {}> {
 
 export type Key = string | number | any;
 
-export type RefObject<T> = { current: T | null };
+export type RefObject<T> = { current: T };
 export type RefCallback<T> = (instance: T | null) => void | (() => void);
-export type Ref<T> = RefObject<T> | RefCallback<T> | null;
+export type Ref<T> = RefCallback<T> | RefObject<T | null> | null;
 
 export type ComponentChild =
 	| VNode<any>
@@ -92,14 +92,12 @@ export type ComponentProps<
 export interface FunctionComponent<P = {}> {
 	(props: RenderableProps<P>, context?: any): ComponentChildren;
 	displayName?: string;
-	defaultProps?: Partial<P> | undefined;
 }
 export interface FunctionalComponent<P = {}> extends FunctionComponent<P> {}
 
 export interface ComponentClass<P = {}, S = {}> {
 	new (props: P, context?: any): Component<P, S>;
 	displayName?: string;
-	defaultProps?: Partial<P>;
 	contextType?: Context<any>;
 	getDerivedStateFromProps?(
 		props: Readonly<P>,
@@ -117,6 +115,7 @@ export type AnyComponent<P = {}, S = {}> =
 	| FunctionComponent<P>
 	| ComponentConstructor<P, S>;
 
+// eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export interface Component<P = {}, S = {}> {
 	componentWillMount?(): void;
 	componentDidMount?(): void;
@@ -146,7 +145,6 @@ export abstract class Component<P, S> {
 	constructor(props?: P, context?: any);
 
 	static displayName?: string;
-	static defaultProps?: any;
 	static contextType?: Context<any>;
 
 	// Static members cannot reference class type parameters. This is not
@@ -164,7 +162,6 @@ export abstract class Component<P, S> {
 	state: Readonly<S>;
 	props: RenderableProps<P>;
 	context: any;
-	base?: Element | Text;
 
 	// From https://github.com/DefinitelyTyped/DefinitelyTyped/blob/e836acc75a78cf0655b5dfdbe81d69fdd4d8a252/types/react/index.d.ts#L402
 	// // We MUST keep setState() as a unified signature because it allows proper checking of the method return type.
@@ -269,25 +266,17 @@ export interface ContainerNode {
 	readonly firstChild: ContainerNode | null;
 	readonly childNodes: ArrayLike<ContainerNode>;
 
-	contains(other: ContainerNode | null): boolean;
 	insertBefore(node: ContainerNode, child: ContainerNode | null): ContainerNode;
 	appendChild(node: ContainerNode): ContainerNode;
 	removeChild(child: ContainerNode): ContainerNode;
 }
 
 export function render(vnode: ComponentChild, parent: ContainerNode): void;
-/**
- * @deprecated The `replaceNode` parameter will be removed in v11.
- *
- * Replacement Preact 10+ implementation can be found in the `preact-root-fragment` package.
- * Docs: https://github.com/preactjs/preact-root-fragment
- */
-export function render(
-	vnode: ComponentChild,
-	parent: ContainerNode,
-	replaceNode?: Element | Text
-): void;
 export function hydrate(vnode: ComponentChild, parent: ContainerNode): void;
+export function createPortal(
+	vnode: ComponentChildren,
+	container: ContainerNode
+): VNode<any>;
 export function cloneElement(
 	vnode: VNode<any>,
 	props?: any,

package/preact/src/index.js

@@ -4,10 +4,11 @@ export {
 	createElement as h,
 	Fragment,
 	createRef,
+	cloneElement,
 	isValidElement
 } from './create-element';
 export { BaseComponent as Component } from './component';
-export { cloneElement } from './clone-element';
 export { createContext } from './create-context';
+export { createPortal } from './create-portal';
 export { toChildArray } from './diff/children';
 export { default as options } from './options';

package/preact/src/internal.d.ts

@@ -1,6 +1,4 @@
-// Intentionally not using a relative path to take advantage of
-// the TS version resolution mechanism
-import * as preact from 'preact';
+import * as preact from './index';
 
 export enum HookType {
 	useState = 1,
@@ -67,10 +65,6 @@ export interface FunctionComponent<P = {}> extends preact.FunctionComponent<P> {
 	// implement the Consumer component
 	contextType?: PreactContext;
 
-	// Internally, createContext stores a ref to the context object on the Provider
-	// Function component to help devtools
-	_contextRef?: PreactContext;
-
 	// Define these properties as undefined on FunctionComponent to get rid of
 	// some errors in `diff()`
 	getDerivedStateFromProps?: undefined;
@@ -78,8 +72,6 @@ export interface FunctionComponent<P = {}> extends preact.FunctionComponent<P> {
 }
 
 export interface ComponentClass<P = {}> extends preact.ComponentClass<P> {
-	_contextRef?: any;
-
 	// Override public contextType with internal PreactContext type
 	contextType?: PreactContext;
 }
@@ -94,6 +86,8 @@ export interface PreactElement extends preact.ContainerNode {
 	data?: CharacterData['data'];
 	// Property to set __dangerouslySetInnerHTML
 	innerHTML?: Element['innerHTML'];
+	textContent?: Element['textContent'];
+	remove?: Element['remove'];
 
 	// Attribute reading and setting
 	readonly attributes?: Element['attributes'];
@@ -104,6 +98,11 @@ export interface PreactElement extends preact.ContainerNode {
 	addEventListener?: Element['addEventListener'];
 	removeEventListener?: Element['removeEventListener'];
 
+	// Used to match DOM nodes to VNodes during hydration
+	readonly ownerDocument: Document;
+	// Used to retarget a Document render to its root element
+	readonly documentElement?: PreactElement | null;
+
 	// Setting styles
 	readonly style?: CSSStyleDeclaration;
 
@@ -122,12 +121,14 @@ export interface PreactElement extends preact.ContainerNode {
 	_children?: VNode<any> | null;
 	/** Event listeners to support event delegation */
 	_listeners?: Record<string, (e: Event) => void>;
+	/** Event clock value at which each listener was attached, kept when `_listeners` is reset on unmount */
+	_attached?: Record<string, number>;
 }
 
 export interface PreactEvent extends Event {
-	// Keyed by a per-instance unique string (e.g. `__dXXXXX`) so that
-	// multiple Preact copies on the same page don't share event clock stamps.
-	[key: string]: any;
+	// Keyed by a per-instance unique Symbol so that multiple Preact copies
+	// on the same page don't share event clock stamps.
+	[key: symbol]: any;
 }
 
 // We use the `current` property to differentiate between the two kinds of Refs so
@@ -140,9 +141,7 @@ type RefCallback<T> = {
 export type Ref<T> = RefObject<T> | RefCallback<T>;
 
 export interface VNode<P = {}> extends preact.VNode<P> {
-	// Redefine type here using our internal ComponentType type, and specify
-	// string has an undefined `defaultProps` property to make TS happy
-	type: (string & { defaultProps: undefined }) | ComponentType<P>;
+	type: string | ComponentType<P>;
 	props: P & { children: ComponentChildren };
 	ref?: Ref<any> | null;
 	_children: Array<VNode<any>> | null;
@@ -166,26 +165,19 @@ export interface Component<P = {}, S = {}> extends Omit<
 	// When component is functional component, this is reset to functional component
 	constructor: ComponentType<P>;
 	state: S; // Override Component["state"] to not be readonly for internal use, specifically Hooks
-	base?: PreactElement;
 
-	_dirty: boolean;
-	_force?: boolean;
+	_excess?: PreactElement;
 	_renderCallbacks: Array<() => void>; // Only class components
 	_stateCallbacks: Array<() => void>; // Only class components
 	_globalContext?: any;
 	_vnode?: VNode<P> | null;
 	_nextState?: S | null; // Only class components
-	/** Only used in the devtools to later dirty check if state has changed */
-	_prevState?: S | null;
 	/**
 	 * Pointer to the parent dom node. This is only needed for top-level Fragment
 	 * components or array returns.
 	 */
 	_parentDom?: PreactElement | null;
-	// Always read, set only when handling error
-	_processingException?: Component<any, any> | null;
-	// Always read, set only when handling error. This is used to indicate at diffTime to set _processingException
-	_pendingError?: Component<any, any> | null;
+	_bits: number;
 }
 
 export interface PreactContext extends preact.Context<any> {