@bpmn-io/properties-panel 0.8.0 → 0.10.1

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;
+			}
+		}
+	}
+};

package/preact/compat/src/scheduler.js

@@ -0,0 +1,24 @@
+// This file includes experimental React APIs exported from the "scheduler"
+// npm package. Despite being explicitely marked as unstable some libraries
+// already make use of them. This file is not a full replacement for the
+// scheduler package, but includes the necessary shims to make those libraries
+// work with Preact.
+
+export const unstable_ImmediatePriority = 1;
+export const unstable_UserBlockingPriority = 2;
+export const unstable_NormalPriority = 3;
+export const unstable_LowPriority = 4;
+export const unstable_IdlePriority = 5;
+
+/**
+ * @param {number} priority
+ * @param {() => void} callback
+ */
+export function unstable_runWithPriority(priority, callback) {
+	return callback();
+}
+
+export const unstable_now =
+	typeof performance === 'object' && typeof performance.now === 'function'
+		? performance.now.bind(performance)
+		: () => Date.now();

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

@@ -0,0 +1,14 @@
+import { Component, ComponentChild } from '../../src';
+
+//
+// SuspenseList
+// -----------------------------------
+
+export interface SuspenseListProps {
+	children?: preact.ComponentChildren;
+	revealOrder?: 'forwards' | 'backwards' | 'together';
+}
+
+export class SuspenseList extends Component<SuspenseListProps> {
+	render(): ComponentChild;
+}

package/preact/compat/src/suspense-list.js

@@ -0,0 +1,126 @@
+import { Component, toChildArray } from '../..';
+import { suspended } from './suspense.js';
+
+// Indexes to linked list nodes (nodes are stored as arrays to save bytes).
+const SUSPENDED_COUNT = 0;
+const RESOLVED_COUNT = 1;
+const NEXT_NODE = 2;
+
+// Having custom inheritance instead of a class here saves a lot of bytes.
+export function SuspenseList() {
+	this._next = null;
+	this._map = null;
+}
+
+// Mark one of child's earlier suspensions as resolved.
+// Some pending callbacks may become callable due to this
+// (e.g. the last suspended descendant gets resolved when
+// revealOrder === 'together'). Process those callbacks as well.
+const resolve = (list, child, node) => {
+	if (++node[RESOLVED_COUNT] === node[SUSPENDED_COUNT]) {
+		// The number a child (or any of its descendants) has been suspended
+		// matches the number of times it's been resolved. Therefore we
+		// mark the child as completely resolved by deleting it from ._map.
+		// This is used to figure out when *all* children have been completely
+		// resolved when revealOrder is 'together'.
+		list._map.delete(child);
+	}
+
+	// If revealOrder is falsy then we can do an early exit, as the
+	// callbacks won't get queued in the node anyway.
+	// If revealOrder is 'together' then also do an early exit
+	// if all suspended descendants have not yet been resolved.
+	if (
+		!list.props.revealOrder ||
+		(list.props.revealOrder[0] === 't' && list._map.size)
+	) {
+		return;
+	}
+
+	// Walk the currently suspended children in order, calling their
+	// stored callbacks on the way. Stop if we encounter a child that
+	// has not been completely resolved yet.
+	node = list._next;
+	while (node) {
+		while (node.length > 3) {
+			node.pop()();
+		}
+		if (node[RESOLVED_COUNT] < node[SUSPENDED_COUNT]) {
+			break;
+		}
+		list._next = node = node[NEXT_NODE];
+	}
+};
+
+// Things we do here to save some bytes but are not proper JS inheritance:
+// - call `new Component()` as the prototype
+// - do not set `Suspense.prototype.constructor` to `Suspense`
+SuspenseList.prototype = new Component();
+
+SuspenseList.prototype._suspended = function(child) {
+	const list = this;
+	const delegated = suspended(list._vnode);
+
+	let node = list._map.get(child);
+	node[SUSPENDED_COUNT]++;
+
+	return unsuspend => {
+		const wrappedUnsuspend = () => {
+			if (!list.props.revealOrder) {
+				// Special case the undefined (falsy) revealOrder, as there
+				// is no need to coordinate a specific order or unsuspends.
+				unsuspend();
+			} else {
+				node.push(unsuspend);
+				resolve(list, child, node);
+			}
+		};
+		if (delegated) {
+			delegated(wrappedUnsuspend);
+		} else {
+			wrappedUnsuspend();
+		}
+	};
+};
+
+SuspenseList.prototype.render = function(props) {
+	this._next = null;
+	this._map = new Map();
+
+	const children = toChildArray(props.children);
+	if (props.revealOrder && props.revealOrder[0] === 'b') {
+		// If order === 'backwards' (or, well, anything starting with a 'b')
+		// then flip the child list around so that the last child will be
+		// the first in the linked list.
+		children.reverse();
+	}
+	// Build the linked list. Iterate through the children in reverse order
+	// so that `_next` points to the first linked list node to be resolved.
+	for (let i = children.length; i--; ) {
+		// Create a new linked list node as an array of form:
+		// 	[suspended_count, resolved_count, next_node]
+		// where suspended_count and resolved_count are numeric counters for
+		// keeping track how many times a node has been suspended and resolved.
+		//
+		// Note that suspended_count starts from 1 instead of 0, so we can block
+		// processing callbacks until componentDidMount has been called. In a sense
+		// node is suspended at least until componentDidMount gets called!
+		//
+		// Pending callbacks are added to the end of the node:
+		// 	[suspended_count, resolved_count, next_node, callback_0, callback_1, ...]
+		this._map.set(children[i], (this._next = [1, 0, this._next]));
+	}
+	return props.children;
+};
+
+SuspenseList.prototype.componentDidUpdate = SuspenseList.prototype.componentDidMount = function() {
+	// Iterate through all children after mounting for two reasons:
+	// 1. As each node[SUSPENDED_COUNT] starts from 1, this iteration increases
+	//    each node[RELEASED_COUNT] by 1, therefore balancing the counters.
+	//    The nodes can now be completely consumed from the linked list.
+	// 2. Handle nodes that might have gotten resolved between render and
+	//    componentDidMount.
+	this._map.forEach((node, child) => {
+		resolve(this, child, node);
+	});
+};

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

@@ -0,0 +1,15 @@
+import { Component, ComponentChild } from '../../src';
+
+//
+// Suspense/lazy
+// -----------------------------------
+export function lazy<T>(loader: () => Promise<{ default: T }>): T;
+
+export interface SuspenseProps {
+	children?: preact.ComponentChildren;
+	fallback: preact.ComponentChildren;
+}
+
+export class Suspense extends Component<SuspenseProps> {
+	render(): ComponentChild;
+}