@bpmn-io/properties-panel 0.7.0 → 0.10.0

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

@@ -0,0 +1,140 @@
+import * as _hooks from '../../hooks';
+import * as preact from '../../src';
+import { JSXInternal } from '../../src/jsx';
+import * as _Suspense from './suspense';
+import * as _SuspenseList from './suspense-list';
+
+// export default React;
+export = React;
+export as namespace React;
+declare namespace React {
+	// Export JSX
+	export import JSX = JSXInternal;
+
+	// Hooks
+	export import CreateHandle = _hooks.CreateHandle;
+	export import EffectCallback = _hooks.EffectCallback;
+	export import Inputs = _hooks.Inputs;
+	export import PropRef = _hooks.PropRef;
+	export import Reducer = _hooks.Reducer;
+	export import Ref = _hooks.Ref;
+	export import StateUpdater = _hooks.StateUpdater;
+	export import useCallback = _hooks.useCallback;
+	export import useContext = _hooks.useContext;
+	export import useDebugValue = _hooks.useDebugValue;
+	export import useEffect = _hooks.useEffect;
+	export import useImperativeHandle = _hooks.useImperativeHandle;
+	export import useLayoutEffect = _hooks.useLayoutEffect;
+	export import useMemo = _hooks.useMemo;
+	export import useReducer = _hooks.useReducer;
+	export import useRef = _hooks.useRef;
+	export import useState = _hooks.useState;
+
+	// Preact Defaults
+	export import Component = preact.Component;
+	export import FunctionComponent = preact.FunctionComponent;
+	export import FC = preact.FunctionComponent;
+	export import createContext = preact.createContext;
+	export import createRef = preact.createRef;
+	export import Fragment = preact.Fragment;
+	export import createElement = preact.createElement;
+	export import cloneElement = preact.cloneElement;
+
+	// Suspense
+	export import Suspense = _Suspense.Suspense;
+	export import lazy = _Suspense.lazy;
+	export import SuspenseList = _SuspenseList.SuspenseList;
+
+	// Compat
+	export import StrictMode = preact.Fragment;
+	export const version: string;
+
+	export function createPortal(
+		vnode: preact.VNode,
+		container: Element
+	): preact.VNode<any>;
+
+	export function render(
+		vnode: preact.VNode<any>,
+		parent: Element,
+		callback?: () => void
+	): Component | null;
+
+	export function hydrate(
+		vnode: preact.VNode<any>,
+		parent: Element,
+		callback?: () => void
+	): Component | null;
+
+	export function unmountComponentAtNode(
+		container: Element | Document | ShadowRoot | DocumentFragment
+	): boolean;
+
+	export function createFactory(
+		type: preact.VNode<any>['type']
+	): (
+		props?: any,
+		...children: preact.ComponentChildren[]
+	) => preact.VNode<any>;
+	export function isValidElement(element: any): boolean;
+	export function findDOMNode(component: preact.Component): Element | null;
+
+	export abstract class PureComponent<P = {}, S = {}> extends preact.Component<
+		P,
+		S
+	> {
+		isPureReactComponent: boolean;
+	}
+
+	export function memo<P = {}>(
+		component: preact.FunctionalComponent<P>,
+		comparer?: (prev: P, next: P) => boolean
+	): preact.FunctionComponent<P>;
+	export function memo<C extends preact.FunctionalComponent<any>>(
+		component: C,
+		comparer?: (
+			prev: preact.ComponentProps<C>,
+			next: preact.ComponentProps<C>
+		) => boolean
+	): C;
+
+	export interface ForwardFn<P = {}, T = any> {
+		(props: P, ref: Ref<T>): preact.ComponentChild;
+		displayName?: string;
+	}
+
+	export function forwardRef<R, P = {}>(
+		fn: ForwardFn<P, R>
+	): preact.FunctionalComponent<P>;
+
+	export function unstable_batchedUpdates(
+		callback: (arg?: any) => void,
+		arg?: any
+	): void;
+
+	export const Children: {
+		map<T extends preact.ComponentChild, R>(
+			children: T | T[],
+			fn: (child: T, i: number) => R
+		): R[];
+		forEach<T extends preact.ComponentChild>(
+			children: T | T[],
+			fn: (child: T, i: number) => void
+		): void;
+		count: (children: preact.ComponentChildren) => number;
+		only: (children: preact.ComponentChildren) => preact.ComponentChild;
+		toArray: (children: preact.ComponentChildren) => preact.VNode<{}>[];
+	};
+
+	// scheduler
+	export const unstable_ImmediatePriority: number;
+	export const unstable_UserBlockingPriority: number;
+	export const unstable_NormalPriority: number;
+	export const unstable_LowPriority: number;
+	export const unstable_IdlePriority: number;
+	export function unstable_runWithPriority(
+		priority: number,
+		callback: () => void
+	): void;
+	export const unstable_now: () => number;
+}

package/preact/compat/src/index.js

@@ -0,0 +1,175 @@
+import {
+	createElement,
+	render as preactRender,
+	cloneElement as preactCloneElement,
+	createRef,
+	Component,
+	createContext,
+	Fragment
+} from '../..';
+import {
+	useState,
+	useReducer,
+	useEffect,
+	useLayoutEffect,
+	useRef,
+	useImperativeHandle,
+	useMemo,
+	useCallback,
+	useContext,
+	useDebugValue
+} 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 {
+	hydrate,
+	render,
+	REACT_ELEMENT_TYPE,
+	__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
+} from './render';
+export * from './scheduler';
+
+const version = '16.8.0'; // trick libraries to think we are react
+
+/**
+ * Legacy version of createElement.
+ * @param {import('./internal').VNode["type"]} type The node name or Component constructor
+ */
+function createFactory(type) {
+	return createElement.bind(null, type);
+}
+
+/**
+ * Check if the passed element is a valid (p)react node.
+ * @param {*} element The element to check
+ * @returns {boolean}
+ */
+function isValidElement(element) {
+	return !!element && element.$$typeof === REACT_ELEMENT_TYPE;
+}
+
+/**
+ * Wrap `cloneElement` to abort if the passed element is not a valid element and apply
+ * all vnode normalizations.
+ * @param {import('./internal').VNode} element The vnode to clone
+ * @param {object} props Props to add when cloning
+ * @param {Array<import('./internal').ComponentChildren>} rest Optional component children
+ */
+function cloneElement(element) {
+	if (!isValidElement(element)) return element;
+	return preactCloneElement.apply(null, arguments);
+}
+
+/**
+ * Remove a component tree from the DOM, including state and event handlers.
+ * @param {import('./internal').PreactElement} container
+ * @returns {boolean}
+ */
+function unmountComponentAtNode(container) {
+	if (container._children) {
+		preactRender(null, container);
+		return true;
+	}
+	return false;
+}
+
+/**
+ * Get the matching DOM node for a component
+ * @param {import('./internal').Component} component
+ * @returns {import('./internal').PreactElement | null}
+ */
+function findDOMNode(component) {
+	return (
+		(component &&
+			(component.base || (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);
+
+/**
+ * Strict Mode is not implemented in Preact, so we provide a stand-in for it
+ * that just renders its children without imposing any restrictions.
+ */
+const StrictMode = Fragment;
+
+export * from '../../hooks';
+export {
+	version,
+	Children,
+	render,
+	hydrate,
+	unmountComponentAtNode,
+	createPortal,
+	createElement,
+	createContext,
+	createFactory,
+	cloneElement,
+	createRef,
+	Fragment,
+	isValidElement,
+	findDOMNode,
+	Component,
+	PureComponent,
+	memo,
+	forwardRef,
+	// eslint-disable-next-line camelcase
+	unstable_batchedUpdates,
+	StrictMode,
+	Suspense,
+	SuspenseList,
+	lazy,
+	__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
+};
+
+// React copies the named exports to the default one.
+export default {
+	useState,
+	useReducer,
+	useEffect,
+	useLayoutEffect,
+	useRef,
+	useImperativeHandle,
+	useMemo,
+	useCallback,
+	useContext,
+	useDebugValue,
+	version,
+	Children,
+	render,
+	hydrate,
+	unmountComponentAtNode,
+	createPortal,
+	createElement,
+	createContext,
+	createFactory,
+	cloneElement,
+	createRef,
+	Fragment,
+	isValidElement,
+	findDOMNode,
+	Component,
+	PureComponent,
+	memo,
+	forwardRef,
+	unstable_batchedUpdates,
+	StrictMode,
+	Suspense,
+	SuspenseList,
+	lazy,
+	__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED
+};

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

@@ -0,0 +1,47 @@
+import {
+	Component as PreactComponent,
+	VNode as PreactVNode,
+	FunctionComponent as PreactFunctionComponent
+} from '../../src/internal';
+import { SuspenseProps } from './suspense';
+
+export { ComponentChildren } from '../..';
+
+export { PreactElement } from '../../src/internal';
+
+export interface Component<P = {}, S = {}> extends PreactComponent<P, S> {
+	isReactComponent?: object;
+	isPureReactComponent?: true;
+	_patchedLifecycles?: true;
+
+	// Suspense internal properties
+	_childDidSuspend?(error: Promise<void>, suspendingVNode: VNode): void;
+	_suspended: (vnode: VNode) => (unsuspend: () => void) => void;
+	_onResolve?(): void;
+
+	// Portal internal properties
+	_temp: any;
+	_container: PreactElement;
+}
+
+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;
+	preactCompatNormalized?: boolean;
+}
+
+export interface SuspenseState {
+	_suspended?: null | VNode<any>;
+}
+
+export interface SuspenseComponent
+	extends PreactComponent<SuspenseProps, SuspenseState> {
+	_pendingSuspensionCount: number;
+	_suspenders: Component[];
+	_detachOnNextRender: null | VNode<any>;
+}

package/preact/compat/src/memo.js

@@ -0,0 +1,34 @@
+import { createElement } from '../..';
+import { shallowDiffers } from './util';
+
+/**
+ * Memoize a component, so that it only updates when the props actually have
+ * changed. This was previously known as `React.pure`.
+ * @param {import('./internal').FunctionComponent} c functional component
+ * @param {(prev: object, next: object) => boolean} [comparer] Custom equality function
+ * @returns {import('./internal').FunctionComponent}
+ */
+export function memo(c, comparer) {
+	function shouldUpdate(nextProps) {
+		let ref = this.props.ref;
+		let updateRef = ref == nextProps.ref;
+		if (!updateRef && ref) {
+			ref.call ? ref(null) : (ref.current = null);
+		}
+
+		if (!comparer) {
+			return shallowDiffers(this.props, nextProps);
+		}
+
+		return !comparer(this.props, nextProps) || !updateRef;
+	}
+
+	function Memoed(props) {
+		this.shouldComponentUpdate = shouldUpdate;
+		return createElement(c, props);
+	}
+	Memoed.displayName = 'Memo(' + (c.displayName || c.name) + ')';
+	Memoed.prototype.isReactComponent = true;
+	Memoed._forwarded = true;
+	return Memoed;
+}

package/preact/compat/src/portals.js

@@ -0,0 +1,80 @@
+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();
+	}
+
+	// When props.vnode is undefined/false/null we are dealing with some kind of
+	// conditional vnode. This should not trigger a render.
+	if (props._vnode) {
+		if (!_this._temp) {
+			_this._container = container;
+
+			// Create a fake DOM parent node that manages a subset of `container`'s children:
+			_this._temp = {
+				nodeType: 1,
+				parentNode: container,
+				childNodes: [],
+				appendChild(child) {
+					this.childNodes.push(child);
+					_this._container.appendChild(child);
+				},
+				insertBefore(child, before) {
+					this.childNodes.push(child);
+					_this._container.appendChild(child);
+				},
+				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
+		);
+	}
+	// When we come from a conditional render, on a mounted
+	// portal we should clear the DOM.
+	else if (_this._temp) {
+		_this.componentWillUnmount();
+	}
+}
+
+/**
+ * Create a `Portal` to continue rendering the vnode tree at a different DOM node
+ * @param {import('./internal').VNode} vnode The vnode to render
+ * @param {import('./internal').PreactElement} container The DOM node to continue rendering in to.
+ */
+export function createPortal(vnode, container) {
+	return createElement(Portal, { _vnode: vnode, _container: container });
+}

package/preact/compat/src/render.js

@@ -0,0 +1,219 @@
+import {
+	render as preactRender,
+	hydrate as preactHydrate,
+	options,
+	toChildArray,
+	Component
+} from '../..';
+
+export const REACT_ELEMENT_TYPE =
+	(typeof Symbol != 'undefined' && Symbol.for && Symbol.for('react.element')) ||
+	0xeac7;
+
+const CAMEL_PROPS = /^(?:accent|alignment|arabic|baseline|cap|clip(?!PathU)|color|fill|flood|font|glyph(?!R)|horiz|marker(?!H|W|U)|overline|paint|stop|strikethrough|stroke|text(?!L)|underline|unicode|units|v|vector|vert|word|writing|x(?!C))[A-Z]/;
+
+// 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/i
+		: /fil|che|ra/i
+	).test(type);
+
+// Some libraries like `react-virtualized` explicitly check for this.
+Component.prototype.isReactComponent = {};
+
+// `UNSAFE_*` lifecycle hooks
+// Preact only ever invokes the unprefixed methods.
+// Here we provide a base "fallback" implementation that calls any defined UNSAFE_ prefixed method.
+// - If a component defines its own `componentDidMount()` (including via defineProperty), use that.
+// - If a component defines `UNSAFE_componentDidMount()`, `componentDidMount` is the alias getter/setter.
+// - If anything assigns to an `UNSAFE_*` property, the assignment is forwarded to the unprefixed property.
+// See https://github.com/preactjs/preact/issues/1941
+[
+	'componentWillMount',
+	'componentWillReceiveProps',
+	'componentWillUpdate'
+].forEach(key => {
+	Object.defineProperty(Component.prototype, key, {
+		configurable: true,
+		get() {
+			return this['UNSAFE_' + key];
+		},
+		set(v) {
+			Object.defineProperty(this, key, {
+				configurable: true,
+				writable: true,
+				value: v
+			});
+		}
+	});
+});
+
+/**
+ * Proxy render() since React returns a Component reference.
+ * @param {import('./internal').VNode} vnode VNode tree to render
+ * @param {import('./internal').PreactElement} parent DOM node to render vnode tree into
+ * @param {() => void} [callback] Optional callback that will be called after rendering
+ * @returns {import('./internal').Component | null} The root component reference or null
+ */
+export function render(vnode, parent, callback) {
+	// React destroys any existing DOM nodes, see #1727
+	// ...but only on the first render, see #1828
+	if (parent._children == null) {
+		parent.textContent = '';
+	}
+
+	preactRender(vnode, parent);
+	if (typeof callback == 'function') callback();
+
+	return vnode ? vnode._component : null;
+}
+
+export function hydrate(vnode, parent, callback) {
+	preactHydrate(vnode, parent);
+	if (typeof callback == 'function') callback();
+
+	return vnode ? vnode._component : null;
+}
+
+let oldEventHook = options.event;
+options.event = e => {
+	if (oldEventHook) e = oldEventHook(e);
+	e.persist = empty;
+	e.isPropagationStopped = isPropagationStopped;
+	e.isDefaultPrevented = isDefaultPrevented;
+	return (e.nativeEvent = e);
+};
+
+function empty() {}
+
+function isPropagationStopped() {
+	return this.cancelBubble;
+}
+
+function isDefaultPrevented() {
+	return this.defaultPrevented;
+}
+
+let classNameDescriptor = {
+	configurable: true,
+	get() {
+		return this.class;
+	}
+};
+
+let oldVNodeHook = options.vnode;
+options.vnode = vnode => {
+	let type = vnode.type;
+	let props = vnode.props;
+	let normalizedProps = props;
+
+	// only normalize props on Element nodes
+	if (typeof type === 'string') {
+		normalizedProps = {};
+
+		for (let i in props) {
+			let value = props[i];
+
+			if (i === 'value' && 'defaultValue' in props && value == null) {
+				// Skip applying value if it is null/undefined and we already set
+				// a default value
+				continue;
+			} 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) {
+				// 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 (/ondoubleclick/i.test(i)) {
+				i = 'ondblclick';
+			} else if (
+				/^onchange(textarea|input)/i.test(i + type) &&
+				!onChangeInputType(props.type)
+			) {
+				i = 'oninput';
+			} else if (/^on(Ani|Tra|Tou|BeforeInp)/.test(i)) {
+				i = i.toLowerCase();
+			} else if (CAMEL_PROPS.test(i)) {
+				i = i.replace(/[A-Z0-9]/, '-$&').toLowerCase();
+			} else if (value === null) {
+				value = undefined;
+			}
+
+			normalizedProps[i] = value;
+		}
+
+		// Add support for array select values: <select multiple value={[]} />
+		if (
+			type == 'select' &&
+			normalizedProps.multiple &&
+			Array.isArray(normalizedProps.value)
+		) {
+			// forEach() always returns undefined, which we abuse here to unset the value prop.
+			normalizedProps.value = toChildArray(props.children).forEach(child => {
+				child.props.selected =
+					normalizedProps.value.indexOf(child.props.value) != -1;
+			});
+		}
+
+		// Adding support for defaultValue in select tag
+		if (type == 'select' && normalizedProps.defaultValue != null) {
+			normalizedProps.value = toChildArray(props.children).forEach(child => {
+				if (normalizedProps.multiple) {
+					child.props.selected =
+						normalizedProps.defaultValue.indexOf(child.props.value) != -1;
+				} else {
+					child.props.selected =
+						normalizedProps.defaultValue == child.props.value;
+				}
+			});
+		}
+
+		vnode.props = normalizedProps;
+	}
+
+	if (type && props.class != props.className) {
+		classNameDescriptor.enumerable = 'className' in props;
+		if (props.className != null) normalizedProps.class = props.className;
+		Object.defineProperty(normalizedProps, 'className', classNameDescriptor);
+	}
+
+	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;
+};
+
+// This is a very very private internal function for React it
+// is used to sort-of do runtime dependency injection. So far
+// only `react-relay` makes use of it. It uses it to read the
+// context value.
+export const __SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED = {
+	ReactCurrentDispatcher: {
+		current: {
+			readContext(context) {
+				return currentComponent._globalContext[context._id].props.value;
+			}
+		}
+	}
+};