@bpmn-io/properties-panel 0.9.0 → 0.10.0

package/preact/src/index.d.ts

@@ -0,0 +1,310 @@
+export = preact;
+export as namespace preact;
+
+import { JSXInternal } from './jsx';
+
+declare namespace preact {
+	export import JSX = JSXInternal;
+
+	//
+	// Preact Virtual DOM
+	// -----------------------------------
+
+	interface VNode<P = {}> {
+		type: ComponentType<P> | string;
+		props: P & { children: ComponentChildren };
+		key: Key;
+		/**
+		 * ref is not guaranteed by React.ReactElement, for compatibility reasons
+		 * with popular react libs we define it as optional too
+		 */
+		ref?: Ref<any> | null;
+		/**
+		 * The time this `vnode` started rendering. Will only be set when
+		 * the devtools are attached.
+		 * Default value: `0`
+		 */
+		startTime?: number;
+		/**
+		 * The time that the rendering of this `vnode` was completed. Will only be
+		 * set when the devtools are attached.
+		 * Default value: `-1`
+		 */
+		endTime?: number;
+	}
+
+	//
+	// Preact Component interface
+	// -----------------------------------
+
+	type Key = string | number | any;
+
+	type RefObject<T> = { current: T | null };
+	type RefCallback<T> = (instance: T | null) => void;
+	type Ref<T> = RefObject<T> | RefCallback<T>;
+
+	type ComponentChild =
+		| VNode<any>
+		| object
+		| string
+		| number
+		| bigint
+		| boolean
+		| null
+		| undefined;
+	type ComponentChildren = ComponentChild[] | ComponentChild;
+
+	interface Attributes {
+		key?: Key;
+		jsx?: boolean;
+	}
+
+	interface ClassAttributes<T> extends Attributes {
+		ref?: Ref<T>;
+	}
+
+	interface PreactDOMAttributes {
+		children?: ComponentChildren;
+		dangerouslySetInnerHTML?: {
+			__html: string;
+		};
+	}
+
+	type RenderableProps<P, RefType = any> = P &
+		Readonly<Attributes & { children?: ComponentChildren; ref?: Ref<RefType> }>;
+
+	type ComponentType<P = {}> = ComponentClass<P> | FunctionComponent<P>;
+	type ComponentFactory<P = {}> = ComponentType<P>;
+
+	type ComponentProps<
+		C extends ComponentType<any> | keyof JSXInternal.IntrinsicElements
+	> = C extends ComponentType<infer P>
+		? P
+		: C extends keyof JSXInternal.IntrinsicElements
+		? JSXInternal.IntrinsicElements[C]
+		: never;
+
+	interface FunctionComponent<P = {}> {
+		(props: RenderableProps<P>, context?: any): VNode<any> | null;
+		displayName?: string;
+		defaultProps?: Partial<P>;
+	}
+	interface FunctionalComponent<P = {}> extends FunctionComponent<P> {}
+
+	interface ComponentClass<P = {}, S = {}> {
+		new (props: P, context?: any): Component<P, S>;
+		displayName?: string;
+		defaultProps?: Partial<P>;
+		contextType?: Context<any>;
+		getDerivedStateFromProps?(
+			props: Readonly<P>,
+			state: Readonly<S>
+		): Partial<S> | null;
+		getDerivedStateFromError?(error: any): Partial<S> | null;
+	}
+	interface ComponentConstructor<P = {}, S = {}> extends ComponentClass<P, S> {}
+
+	// Type alias for a component instance considered generally, whether stateless or stateful.
+	type AnyComponent<P = {}, S = {}> = FunctionComponent<P> | Component<P, S>;
+
+	interface Component<P = {}, S = {}> {
+		componentWillMount?(): void;
+		componentDidMount?(): void;
+		componentWillUnmount?(): void;
+		getChildContext?(): object;
+		componentWillReceiveProps?(nextProps: Readonly<P>, nextContext: any): void;
+		shouldComponentUpdate?(
+			nextProps: Readonly<P>,
+			nextState: Readonly<S>,
+			nextContext: any
+		): boolean;
+		componentWillUpdate?(
+			nextProps: Readonly<P>,
+			nextState: Readonly<S>,
+			nextContext: any
+		): void;
+		getSnapshotBeforeUpdate?(oldProps: Readonly<P>, oldState: Readonly<S>): any;
+		componentDidUpdate?(
+			previousProps: Readonly<P>,
+			previousState: Readonly<S>,
+			snapshot: any
+		): void;
+		componentDidCatch?(error: any, errorInfo: any): void;
+	}
+
+	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
+		// supported in TypeScript. Reusing the same type arguments from `Component`
+		// will lead to an impossible state where one cannot satisfy the type
+		// constraint under no circumstances, see #1356.In general type arguments
+		// seem to be a bit buggy and not supported well at the time of this
+		// writing with TS 3.3.3333.
+		static getDerivedStateFromProps?(
+			props: Readonly<object>,
+			state: Readonly<object>
+		): object | null;
+		static getDerivedStateFromError?(error: any): object | null;
+
+		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.
+		// // See: https://github.com/DefinitelyTyped/DefinitelyTyped/issues/18365#issuecomment-351013257
+		setState<K extends keyof S>(
+			state:
+				| ((
+						prevState: Readonly<S>,
+						props: Readonly<P>
+				  ) => Pick<S, K> | Partial<S> | null)
+				| (Pick<S, K> | Partial<S> | null),
+			callback?: () => void
+		): void;
+
+		forceUpdate(callback?: () => void): void;
+
+		abstract render(
+			props?: RenderableProps<P>,
+			state?: Readonly<S>,
+			context?: any
+		): ComponentChild;
+	}
+
+	//
+	// Preact createElement
+	// -----------------------------------
+
+	function createElement(
+		type: string,
+		props:
+			| (JSXInternal.HTMLAttributes &
+					JSXInternal.SVGAttributes &
+					Record<string, any>)
+			| null,
+		...children: ComponentChildren[]
+	): VNode<any>;
+	function createElement<P>(
+		type: ComponentType<P>,
+		props: (Attributes & P) | null,
+		...children: ComponentChildren[]
+	): VNode<any>;
+	namespace createElement {
+		export import JSX = JSXInternal;
+	}
+
+	function h(
+		type: string,
+		props:
+			| (JSXInternal.HTMLAttributes &
+					JSXInternal.SVGAttributes &
+					Record<string, any>)
+			| null,
+		...children: ComponentChildren[]
+	): VNode<any>;
+	function h<P>(
+		type: ComponentType<P>,
+		props: (Attributes & P) | null,
+		...children: ComponentChildren[]
+	): VNode<any>;
+	namespace h {
+		export import JSX = JSXInternal;
+	}
+
+	//
+	// Preact render
+	// -----------------------------------
+
+	function render(
+		vnode: ComponentChild,
+		parent: Element | Document | ShadowRoot | DocumentFragment,
+		replaceNode?: Element | Text
+	): void;
+	function hydrate(
+		vnode: ComponentChild,
+		parent: Element | Document | ShadowRoot | DocumentFragment
+	): void;
+	function cloneElement(
+		vnode: VNode<any>,
+		props?: any,
+		...children: ComponentChildren[]
+	): VNode<any>;
+	function cloneElement<P>(
+		vnode: VNode<P>,
+		props?: any,
+		...children: ComponentChildren[]
+	): VNode<P>;
+
+	//
+	// Preact Built-in Components
+	// -----------------------------------
+
+	// TODO: Revisit what the public type of this is...
+	const Fragment: ComponentClass<{}, {}>;
+
+	//
+	// Preact options
+	// -----------------------------------
+
+	/**
+	 * Global options for preact
+	 */
+	interface Options {
+		/** Attach a hook that is invoked whenever a VNode is created. */
+		vnode?(vnode: VNode): void;
+		/** Attach a hook that is invoked immediately before a vnode is unmounted. */
+		unmount?(vnode: VNode): void;
+		/** Attach a hook that is invoked after a vnode has rendered. */
+		diffed?(vnode: VNode): void;
+		event?(e: Event): any;
+		requestAnimationFrame?: typeof requestAnimationFrame;
+		debounceRendering?(cb: () => void): void;
+		useDebugValue?(value: string | number): void;
+		_addHookName?(name: string | number): void;
+		__suspenseDidResolve?(vnode: VNode, cb: () => void): void;
+		// __canSuspenseResolve?(vnode: VNode, cb: () => void): void;
+	}
+
+	const options: Options;
+
+	//
+	// Preact helpers
+	// -----------------------------------
+	function createRef<T = any>(): RefObject<T>;
+	function toChildArray(
+		children: ComponentChildren
+	): Array<VNode | string | number>;
+	function isValidElement(vnode: any): vnode is VNode;
+
+	//
+	// Context
+	// -----------------------------------
+	interface Consumer<T>
+		extends FunctionComponent<{
+			children: (value: T) => ComponentChildren;
+		}> {}
+	interface PreactConsumer<T> extends Consumer<T> {}
+
+	interface Provider<T>
+		extends FunctionComponent<{
+			value: T;
+			children: ComponentChildren;
+		}> {}
+	interface PreactProvider<T> extends Provider<T> {}
+
+	interface Context<T> {
+		Consumer: Consumer<T>;
+		Provider: Provider<T>;
+		displayName?: string;
+	}
+	interface PreactContext<T> extends Context<T> {}
+
+	function createContext<T>(defaultValue: T): Context<T>;
+}

package/preact/src/index.js

@@ -0,0 +1,13 @@
+export { render, hydrate } from './render';
+export {
+	createElement,
+	createElement as h,
+	Fragment,
+	createRef,
+	isValidElement
+} from './create-element';
+export { Component } from './component';
+export { cloneElement } from './clone-element';
+export { createContext } from './create-context';
+export { toChildArray } from './diff/children';
+export { default as options } from './options';

package/preact/src/internal.d.ts

@@ -0,0 +1,147 @@
+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 Options extends preact.Options {
+	_vnodeId: number;
+	/** 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): 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
+	_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;
+}