@bpmn-io/properties-panel 3.13.0 → 3.14.0

package/preact/src/index.d.ts

@@ -194,7 +194,10 @@ export function createElement(
 				ClassAttributes<HTMLInputElement>)
 		| null,
 	...children: ComponentChildren[]
-): VNode<any>;
+): VNode<
+	| JSXInternal.DOMAttributes<HTMLInputElement> &
+			ClassAttributes<HTMLInputElement>
+>;
 export function createElement<
 	P extends JSXInternal.HTMLAttributes<T>,
 	T extends HTMLElement
@@ -202,7 +205,7 @@ export function createElement<
 	type: keyof JSXInternal.IntrinsicElements,
 	props: (ClassAttributes<T> & P) | null,
 	...children: ComponentChildren[]
-): VNode<any>;
+): VNode<ClassAttributes<T> & P>;
 export function createElement<
 	P extends JSXInternal.SVGAttributes<T>,
 	T extends HTMLElement
@@ -210,7 +213,7 @@ export function createElement<
 	type: keyof JSXInternal.IntrinsicElements,
 	props: (ClassAttributes<T> & P) | null,
 	...children: ComponentChildren[]
-): VNode<any>;
+): VNode<ClassAttributes<T> & P>;
 export function createElement<T extends HTMLElement>(
 	type: string,
 	props:
@@ -219,12 +222,14 @@ export function createElement<T extends HTMLElement>(
 				JSXInternal.SVGAttributes)
 		| null,
 	...children: ComponentChildren[]
-): VNode<any>;
+): VNode<
+	ClassAttributes<T> & JSXInternal.HTMLAttributes & JSXInternal.SVGAttributes
+>;
 export function createElement<P>(
 	type: ComponentType<P>,
 	props: (Attributes & P) | null,
 	...children: ComponentChildren[]
-): VNode<any>;
+): VNode<P>;
 export namespace createElement {
 	export import JSX = JSXInternal;
 }
@@ -236,7 +241,10 @@ export function h(
 				ClassAttributes<HTMLInputElement>)
 		| null,
 	...children: ComponentChildren[]
-): VNode<any>;
+): VNode<
+	| JSXInternal.DOMAttributes<HTMLInputElement> &
+			ClassAttributes<HTMLInputElement>
+>;
 export function h<
 	P extends JSXInternal.HTMLAttributes<T>,
 	T extends HTMLElement
@@ -244,7 +252,7 @@ export function h<
 	type: keyof JSXInternal.IntrinsicElements,
 	props: (ClassAttributes<T> & P) | null,
 	...children: ComponentChildren[]
-): VNode<any>;
+): VNode<ClassAttributes<T> & P>;
 export function h<
 	P extends JSXInternal.SVGAttributes<T>,
 	T extends HTMLElement
@@ -252,7 +260,7 @@ export function h<
 	type: keyof JSXInternal.IntrinsicElements,
 	props: (ClassAttributes<T> & P) | null,
 	...children: ComponentChildren[]
-): VNode<any>;
+): VNode<ClassAttributes<T> & P>;
 export function h<T extends HTMLElement>(
 	type: string,
 	props:
@@ -261,12 +269,17 @@ export function h<T extends HTMLElement>(
 				JSXInternal.SVGAttributes)
 		| null,
 	...children: ComponentChildren[]
-): VNode<any>;
+): VNode<
+	| (ClassAttributes<T> &
+			JSXInternal.HTMLAttributes &
+			JSXInternal.SVGAttributes)
+	| null
+>;
 export function h<P>(
 	type: ComponentType<P>,
 	props: (Attributes & P) | null,
 	...children: ComponentChildren[]
-): VNode<any>;
+): VNode<Attributes & P>;
 export namespace h {
 	export import JSX = JSXInternal;
 }
@@ -274,15 +287,15 @@ export namespace h {
 //
 // Preact render
 // -----------------------------------
-
 interface ContainerNode {
-	nodeType: Node['nodeType'];
-	parentNode: Node['parentNode'];
-	firstChild: Node['firstChild'];
-	insertBefore: Node['insertBefore'];
-	appendChild: Node['appendChild'];
-	removeChild: Node['removeChild'];
-	childNodes: ArrayLike<Node>;
+	readonly nodeType: number;
+	readonly parentNode: ContainerNode | null;
+	readonly firstChild: ContainerNode | null;
+	readonly childNodes: ArrayLike<ContainerNode>;
+
+	insertBefore(node: ContainerNode, child: ContainerNode | null): ContainerNode;
+	appendChild(node: ContainerNode): ContainerNode;
+	removeChild(child: ContainerNode): ContainerNode;
 }
 
 export function render(vnode: ComponentChild, parent: ContainerNode): void;
@@ -336,6 +349,12 @@ export interface Options {
 	_addHookName?(name: string | number): void;
 	__suspenseDidResolve?(vnode: VNode, cb: () => void): void;
 	// __canSuspenseResolve?(vnode: VNode, cb: () => void): void;
+
+	/**
+	 * Customize attribute serialization when a precompiled JSX transform
+	 * is used.
+	 */
+	attr?(name: string, value: any): string | void;
 }
 
 export const options: Options;
@@ -361,7 +380,7 @@ export interface PreactConsumer<T> extends Consumer<T> {}
 export interface Provider<T>
 	extends FunctionComponent<{
 		value: T;
-		children: ComponentChildren;
+		children?: ComponentChildren;
 	}> {}
 export interface PreactProvider<T> extends Provider<T> {}
 export type ContextType<C extends Context<any>> = C extends Context<infer T>

package/preact/src/index.js

@@ -6,7 +6,7 @@ export {
 	createRef,
 	isValidElement
 } from './create-element';
-export { Component } from './component';
+export { BaseComponent as Component } from './component';
 export { cloneElement } from './clone-element';
 export { createContext } from './create-context';
 export { toChildArray } from './diff/children';

package/preact/src/internal.d.ts

@@ -1,156 +1,186 @@
 import * as preact from './index';
 
-export enum HookType {
-	useState = 1,
-	useReducer = 2,
-	useEffect = 3,
-	useLayoutEffect = 4,
-	useRef = 5,
-	useImperativeHandle = 6,
-	useMemo = 7,
-	useCallback = 8,
-	useContext = 9,
-	useErrorBoundary = 10,
-	// Not a real hook, but the devtools treat is as such
-	useDebugvalue = 11
-}
-
-export interface DevSource {
-	fileName: string;
-	lineNumber: number;
-}
-
-export interface ErrorInfo {
-	componentStack?: string;
-}
-
-export interface Options extends preact.Options {
-	/** Attach a hook that is invoked before render, mainly to check the arguments. */
-	_root?(
-		vnode: ComponentChild,
-		parent: Element | Document | ShadowRoot | DocumentFragment
-	): void;
-	/** Attach a hook that is invoked before a vnode is diffed. */
-	_diff?(vnode: VNode): void;
-	/** Attach a hook that is invoked after a tree was mounted or was updated. */
-	_commit?(vnode: VNode, commitQueue: Component[]): void;
-	/** Attach a hook that is invoked before a vnode has rendered. */
-	_render?(vnode: VNode): void;
-	/** Attach a hook that is invoked before a hook's state is queried. */
-	_hook?(component: Component, index: number, type: HookType): void;
-	/** Bypass effect execution. Currenty only used in devtools for hooks inspection */
-	_skipEffects?: boolean;
-	/** Attach a hook that is invoked after an error is caught in a component but before calling lifecycle hooks */
-	_catchError(
-		error: any,
-		vnode: VNode,
-		oldVNode: VNode | undefined,
-		errorInfo: ErrorInfo | undefined
-	): void;
-}
-
-export type ComponentChild =
-	| VNode<any>
-	| string
-	| number
-	| boolean
-	| null
-	| undefined;
-export type ComponentChildren = ComponentChild[] | ComponentChild;
-
-export interface FunctionComponent<P = {}> extends preact.FunctionComponent<P> {
-	// Internally, createContext uses `contextType` on a Function component to
-	// 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;
-	getDerivedStateFromError?: undefined;
-}
-
-export interface ComponentClass<P = {}> extends preact.ComponentClass<P> {
-	_contextRef?: any;
-
-	// Override public contextType with internal PreactContext type
-	contextType?: PreactContext;
-}
-
-// Redefine ComponentType using our new internal FunctionComponent interface above
-export type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
-
-export interface PreactElement extends HTMLElement {
-	_children?: VNode<any> | null;
-	/** Event listeners to support event delegation */
-	_listeners?: Record<string, (e: Event) => void>;
-
-	// Preact uses this attribute to detect SVG nodes
-	ownerSVGElement?: SVGElement | null;
-
-	// style: HTMLElement["style"]; // From HTMLElement
-
-	data?: string | number; // From Text node
-}
-
-// We use the `current` property to differentiate between the two kinds of Refs so
-// internally we'll define `current` on both to make TypeScript happy
-type RefObject<T> = { current: T | null };
-type RefCallback<T> = { (instance: T | null): void; current: undefined };
-type Ref<T> = RefObject<T> | RefCallback<T>;
-
-export interface VNode<P = {}> extends preact.VNode<P> {
-	// Redefine type here using our internal ComponentType type
-	type: string | ComponentType<P>;
-	props: P & { children: ComponentChildren };
-	ref?: Ref<any> | null;
-	_children: Array<VNode<any>> | null;
-	_parent: VNode | null;
-	_depth: number | null;
-	/**
-	 * The [first (for Fragments)] DOM child of a VNode
-	 */
-	_dom: PreactElement | null;
-	/**
-	 * The last dom child of a Fragment, or components that return a Fragment
-	 */
-	_nextDom: PreactElement | null;
-	_component: Component | null;
-	_hydrating: boolean | null;
-	constructor: undefined;
-	_original: number;
-}
-
-export interface Component<P = {}, S = {}> extends preact.Component<P, S> {
-	// 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;
-	_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;
-}
-
-export interface PreactContext extends preact.Context<any> {
-	_id: string;
-	_defaultValue: any;
+declare global {
+	export enum HookType {
+		useState = 1,
+		useReducer = 2,
+		useEffect = 3,
+		useLayoutEffect = 4,
+		useRef = 5,
+		useImperativeHandle = 6,
+		useMemo = 7,
+		useCallback = 8,
+		useContext = 9,
+		useErrorBoundary = 10,
+		// Not a real hook, but the devtools treat is as such
+		useDebugvalue = 11
+	}
+
+	export interface DevSource {
+		fileName: string;
+		lineNumber: number;
+	}
+
+	export interface ErrorInfo {
+		componentStack?: string;
+	}
+
+	export interface Options extends preact.Options {
+		/** Attach a hook that is invoked before render, mainly to check the arguments. */
+		_root?(vnode: ComponentChild, parent: preact.ContainerNode): void;
+		/** Attach a hook that is invoked before a vnode is diffed. */
+		_diff?(vnode: VNode): void;
+		/** Attach a hook that is invoked after a tree was mounted or was updated. */
+		_commit?(vnode: VNode, commitQueue: Component[]): void;
+		/** Attach a hook that is invoked before a vnode has rendered. */
+		_render?(vnode: VNode): void;
+		/** Attach a hook that is invoked before a hook's state is queried. */
+		_hook?(component: Component, index: number, type: HookType): void;
+		/** Bypass effect execution. Currenty only used in devtools for hooks inspection */
+		_skipEffects?: boolean;
+		/** Attach a hook that is invoked after an error is caught in a component but before calling lifecycle hooks */
+		_catchError(
+			error: any,
+			vnode: VNode,
+			oldVNode?: VNode | undefined,
+			errorInfo?: ErrorInfo | undefined
+		): void;
+	}
+
+	export type ComponentChild =
+		| VNode<any>
+		| string
+		| number
+		| boolean
+		| null
+		| undefined;
+	export type ComponentChildren = ComponentChild[] | ComponentChild;
+
+	export interface FunctionComponent<P = {}>
+		extends preact.FunctionComponent<P> {
+		// Internally, createContext uses `contextType` on a Function component to
+		// 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;
+		getDerivedStateFromError?: undefined;
+	}
+
+	export interface ComponentClass<P = {}> extends preact.ComponentClass<P> {
+		_contextRef?: any;
+
+		// Override public contextType with internal PreactContext type
+		contextType?: PreactContext;
+	}
+
+	// Redefine ComponentType using our new internal FunctionComponent interface above
+	export type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
+
+	export interface PreactElement extends preact.ContainerNode {
+		// SVG detection
+		readonly ownerSVGElement?: SVGElement['ownerSVGElement'];
+		// Property used to update Text nodes
+		data?: CharacterData['data'];
+		// Property to set __dangerouslySetInnerHTML
+		innerHTML?: Element['innerHTML'];
+
+		// Attribute reading and setting
+		readonly attributes?: Element['attributes'];
+		setAttribute?: Element['setAttribute'];
+		removeAttribute?: Element['removeAttribute'];
+
+		// Event listeners
+		addEventListener?: Element['addEventListener'];
+		removeEventListener?: Element['removeEventListener'];
+
+		// Setting styles
+		readonly style?: CSSStyleDeclaration;
+
+		// nextSibling required for inserting nodes
+		readonly nextSibling: ContainerNode | null;
+
+		// Used to match DOM nodes to VNodes during hydration. Note: doesn't exist
+		// on Text nodes
+		readonly localName?: string;
+
+		// Input handling
+		value?: HTMLInputElement['value'];
+		checked?: HTMLInputElement['checked'];
+
+		// Internal properties
+		_children?: VNode<any> | null;
+		/** Event listeners to support event delegation */
+		_listeners?: Record<string, (e: Event) => void>;
+	}
+
+	export interface PreactEvent extends Event {
+		_dispatched?: number;
+	}
+
+	// We use the `current` property to differentiate between the two kinds of Refs so
+	// internally we'll define `current` on both to make TypeScript happy
+	type RefObject<T> = { current: T | null };
+	type RefCallback<T> = { (instance: T | null): void; current: undefined };
+	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>;
+		props: P & { children: ComponentChildren };
+		ref?: Ref<any> | null;
+		_children: Array<VNode<any>> | null;
+		_parent: VNode | null;
+		_depth: number | null;
+		/**
+		 * The [first (for Fragments)] DOM child of a VNode
+		 */
+		_dom: PreactElement | null;
+		/**
+		 * The last dom child of a Fragment, or components that return a Fragment
+		 */
+		_nextDom: PreactElement | null | undefined;
+		_component: Component | null;
+		constructor: undefined;
+		_original: number;
+		_index: number;
+		_flags: number;
+	}
+
+	export interface Component<P = {}, S = {}> extends preact.Component<P, S> {
+		// 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;
+		_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;
+	}
+
+	export interface PreactContext extends preact.Context<any> {
+		_id: string;
+		_defaultValue: any;
+	}
 }