@bpmn-io/properties-panel 0.9.0 → 0.10.0

package/preact/jsx-runtime/src/index.d.ts

@@ -0,0 +1,50 @@
+export { Fragment } from '../../';
+import {
+	ComponentType,
+	ComponentChild,
+	ComponentChildren,
+	VNode,
+	Attributes
+} from '../../';
+import { JSXInternal } from '../../src/jsx';
+
+export function jsx(
+	type: string,
+	props: JSXInternal.HTMLAttributes &
+		JSXInternal.SVGAttributes &
+		Record<string, any> & { children?: ComponentChild },
+	key?: string
+): VNode<any>;
+export function jsx<P>(
+	type: ComponentType<P>,
+	props: Attributes & P & { children?: ComponentChild },
+	key?: string
+): VNode<any>;
+
+export function jsxs(
+	type: string,
+	props: JSXInternal.HTMLAttributes &
+		JSXInternal.SVGAttributes &
+		Record<string, any> & { children?: ComponentChild[] },
+	key?: string
+): VNode<any>;
+export function jsxs<P>(
+	type: ComponentType<P>,
+	props: Attributes & P & { children?: ComponentChild[] },
+	key?: string
+): VNode<any>;
+
+export function jsxDEV(
+	type: string,
+	props: JSXInternal.HTMLAttributes &
+		JSXInternal.SVGAttributes &
+		Record<string, any> & { children?: ComponentChildren },
+	key?: string
+): VNode<any>;
+export function jsxDEV<P>(
+	type: ComponentType<P>,
+	props: Attributes & P & { children?: ComponentChildren },
+	key?: string
+): VNode<any>;
+
+export { JSXInternal as JSX };

package/preact/jsx-runtime/src/index.js

@@ -0,0 +1,72 @@
+import { options, Fragment } from '../..';
+
+/** @typedef {import('preact').VNode} VNode */
+
+/**
+ * @fileoverview
+ * This file exports various methods that implement Babel's "automatic" JSX runtime API:
+ * - jsx(type, props, key)
+ * - jsxs(type, props, key)
+ * - jsxDEV(type, props, key, __source, __self)
+ *
+ * The implementation of createVNode here is optimized for performance.
+ * Benchmarks: https://esbench.com/bench/5f6b54a0b4632100a7dcd2b3
+ */
+
+/**
+ * JSX.Element factory used by Babel's {runtime:"automatic"} JSX transform
+ * @param {VNode['type']} type
+ * @param {VNode['props']} props
+ * @param {VNode['key']} [key]
+ * @param {string} [__source]
+ * @param {string} [__self]
+ */
+function createVNode(type, props, key, __source, __self) {
+	// We'll want to preserve `ref` in props to get rid of the need for
+	// forwardRef components in the future, but that should happen via
+	// a separate PR.
+	let normalizedProps = {};
+	for (let i in props) {
+		if (i != 'ref') {
+			normalizedProps[i] = props[i];
+		}
+	}
+
+	const vnode = {
+		type,
+		props: normalizedProps,
+		key,
+		ref: props && props.ref,
+		_children: null,
+		_parent: null,
+		_depth: 0,
+		_dom: null,
+		_nextDom: undefined,
+		_component: null,
+		_hydrating: null,
+		constructor: undefined,
+		_original: ++options._vnodeId,
+		__source,
+		__self
+	};
+
+	// If a Component VNode, check for and apply defaultProps.
+	// Note: `type` is often a String, and can be `undefined` in development.
+	let defaults, i;
+	if (typeof type === 'function' && (defaults = type.defaultProps)) {
+		for (i in defaults)
+			if (normalizedProps[i] === undefined) {
+				normalizedProps[i] = defaults[i];
+			}
+	}
+
+	if (options.vnode) options.vnode(vnode);
+	return vnode;
+}
+
+export {
+	createVNode as jsx,
+	createVNode as jsxs,
+	createVNode as jsxDEV,
+	Fragment
+};

package/preact/package.json

@@ -0,0 +1,268 @@
+{
+	"name": "preact",
+	"amdName": "preact",
+	"version": "10.5.13",
+	"private": false,
+	"description": "Fast 3kb React-compatible Virtual DOM library.",
+	"main": "dist/preact.js",
+	"module": "dist/preact.module.js",
+	"umd:main": "dist/preact.umd.js",
+	"unpkg": "dist/preact.min.js",
+	"source": "src/index.js",
+	"exports": {
+		".": {
+			"browser": "./dist/preact.module.js",
+			"umd": "./dist/preact.umd.js",
+			"import": "./dist/preact.mjs",
+			"require": "./dist/preact.js"
+		},
+		"./compat": {
+			"browser": "./compat/dist/compat.module.js",
+			"umd": "./compat/dist/compat.umd.js",
+			"require": "./compat/dist/compat.js",
+			"import": "./compat/dist/compat.mjs"
+		},
+		"./debug": {
+			"browser": "./debug/dist/debug.module.js",
+			"umd": "./debug/dist/debug.umd.js",
+			"require": "./debug/dist/debug.js",
+			"import": "./debug/dist/debug.mjs"
+		},
+		"./devtools": {
+			"browser": "./devtools/dist/devtools.module.js",
+			"umd": "./devtools/dist/devtools.umd.js",
+			"require": "./devtools/dist/devtools.js",
+			"import": "./devtools/dist/devtools.mjs"
+		},
+		"./hooks": {
+			"browser": "./hooks/dist/hooks.module.js",
+			"umd": "./hooks/dist/hooks.umd.js",
+			"require": "./hooks/dist/hooks.js",
+			"import": "./hooks/dist/hooks.mjs"
+		},
+		"./test-utils": {
+			"browser": "./test-utils/dist/testUtils.module.js",
+			"umd": "./test-utils/dist/testUtils.umd.js",
+			"require": "./test-utils/dist/testUtils.js",
+			"import": "./test-utils/dist/testUtils.mjs"
+		},
+		"./jsx-runtime": {
+			"browser": "./jsx-runtime/dist/jsxRuntime.module.js",
+			"umd": "./jsx-runtime/dist/jsxRuntime.umd.js",
+			"require": "./jsx-runtime/dist/jsxRuntime.js",
+			"import": "./jsx-runtime/dist/jsxRuntime.mjs"
+		},
+		"./jsx-dev-runtime": {
+			"browser": "./jsx-runtime/dist/jsxRuntime.module.js",
+			"umd": "./jsx-runtime/dist/jsxRuntime.umd.js",
+			"require": "./jsx-runtime/dist/jsxRuntime.js",
+			"import": "./jsx-runtime/dist/jsxRuntime.mjs"
+		},
+		"./compat/server": {
+			"require": "./compat/server.js",
+			"import": "./compat/server.mjs"
+		},
+		"./package.json": "./package.json",
+		"./": "./"
+	},
+	"license": "MIT",
+	"funding": {
+		"type": "opencollective",
+		"url": "https://opencollective.com/preact"
+	},
+	"types": "src/index.d.ts",
+	"scripts": {
+		"prepare": "run-s build && check-export-map",
+		"build": "npm-run-all --parallel build:*",
+		"build:core": "microbundle build --raw",
+		"build:core-min": "microbundle build --raw -f iife src/cjs.js -o dist/preact.min.js",
+		"build:debug": "microbundle build --raw --cwd debug",
+		"build:devtools": "microbundle build --raw --cwd devtools",
+		"build:hooks": "microbundle build --raw --cwd hooks",
+		"build:test-utils": "microbundle build --raw --cwd test-utils",
+		"build:compat": "microbundle build --raw --cwd compat --globals 'preact/hooks=preactHooks'",
+		"build:jsx": "microbundle build --raw --cwd jsx-runtime",
+		"postbuild": "node ./config/node-13-exports.js && node ./config/compat-entries.js",
+		"dev": "microbundle watch --raw --format cjs",
+		"dev:hooks": "microbundle watch --raw --format cjs --cwd hooks",
+		"dev:compat": "microbundle watch --raw --format cjs --cwd compat --globals 'preact/hooks=preactHooks'",
+		"test": "npm-run-all build lint test:unit",
+		"test:unit": "run-p test:mocha test:karma:minify test:ts",
+		"test:ts": "run-p test:ts:*",
+		"test:ts:core": "tsc -p test/ts/ && mocha --require \"@babel/register\" test/ts/**/*-test.js",
+		"test:ts:compat": "tsc -p compat/test/ts/",
+		"test:mocha": "mocha --recursive --require \"@babel/register\" test/shared test/node",
+		"test:mocha:watch": "npm run test:mocha -- --watch",
+		"test:karma": "cross-env COVERAGE=true BABEL_NO_MODULES=true karma start karma.conf.js --single-run",
+		"test:karma:minify": "cross-env COVERAGE=true MINIFY=true BABEL_NO_MODULES=true karma start karma.conf.js --single-run",
+		"test:karma:watch": "cross-env BABEL_NO_MODULES=true karma start karma.conf.js --no-single-run",
+		"test:karma:hooks": "cross-env COVERAGE=false BABEL_NO_MODULES=true karma start karma.conf.js --grep=hooks/test/browser/**.js --no-single-run",
+		"test:karma:test-utils": "cross-env PERFORMANCE=false COVERAGE=false BABEL_NO_MODULES=true karma start karma.conf.js --grep=test-utils/test/shared/**.js --no-single-run",
+		"test:karma:bench": "cross-env PERFORMANCE=true COVERAGE=false BABEL_NO_MODULES=true karma start karma.conf.js --grep=test/benchmarks/**.js --single-run",
+		"benchmark": "npm run test:karma:bench -- no-single-run",
+		"lint": "eslint src test debug compat hooks test-utils"
+	},
+	"eslintConfig": {
+		"extends": [
+			"developit",
+			"prettier"
+		],
+		"settings": {
+			"react": {
+				"pragma": "createElement"
+			}
+		},
+		"rules": {
+			"camelcase": [
+				1,
+				{
+					"allow": [
+						"__test__*",
+						"unstable_*",
+						"UNSAFE_*"
+					]
+				}
+			],
+			"no-unused-vars": [
+				2,
+				{
+					"args": "none",
+					"varsIgnorePattern": "^h|React$"
+				}
+			],
+			"prefer-rest-params": 0,
+			"prefer-spread": 0,
+			"no-cond-assign": 0,
+			"react/jsx-no-bind": 0,
+			"react/no-danger": "off",
+			"react/prefer-stateless-function": 0,
+			"react/sort-comp": 0,
+			"jest/valid-expect": 0,
+			"jest/no-disabled-tests": 0,
+			"react/no-find-dom-node": 0
+		}
+	},
+	"eslintIgnore": [
+		"test/fixtures",
+		"test/ts/",
+		"*.ts",
+		"dist"
+	],
+	"prettier": {
+		"singleQuote": true,
+		"trailingComma": "none",
+		"useTabs": true,
+		"tabWidth": 2
+	},
+	"lint-staged": {
+		"**/*.{js,jsx,ts,tsx,yml}": [
+			"prettier --write"
+		]
+	},
+	"husky": {
+		"hooks": {
+			"pre-commit": "lint-staged"
+		}
+	},
+	"files": [
+		"src",
+		"dist",
+		"compat/dist",
+		"compat/src",
+		"compat/server.js",
+		"compat/server.mjs",
+		"compat/test-utils.js",
+		"compat/jsx-runtime.js",
+		"compat/jsx-runtime.mjs",
+		"compat/jsx-dev-runtime.js",
+		"compat/jsx-dev-runtime.mjs",
+		"compat/package.json",
+		"debug/dist",
+		"debug/src",
+		"debug/package.json",
+		"devtools/dist",
+		"devtools/src",
+		"devtools/package.json",
+		"hooks/dist",
+		"hooks/src",
+		"hooks/package.json",
+		"jsx-runtime/dist",
+		"jsx-runtime/src",
+		"jsx-runtime/package.json",
+		"test-utils/src",
+		"test-utils/package.json",
+		"test-utils/dist"
+	],
+	"keywords": [
+		"preact",
+		"react",
+		"ui",
+		"user interface",
+		"virtual dom",
+		"vdom",
+		"components",
+		"dom diff",
+		"front-end",
+		"framework"
+	],
+	"authors": [
+		"The Preact Authors (https://github.com/preactjs/preact/contributors)"
+	],
+	"repository": "preactjs/preact",
+	"bugs": "https://github.com/preactjs/preact/issues",
+	"homepage": "https://preactjs.com",
+	"devDependencies": {
+		"@babel/core": "^7.7.0",
+		"@babel/plugin-proposal-object-rest-spread": "^7.6.2",
+		"@babel/plugin-transform-react-jsx": "^7.7.0",
+		"@babel/plugin-transform-react-jsx-source": "^7.7.4",
+		"@babel/preset-env": "^7.7.1",
+		"@babel/register": "^7.7.0",
+		"@types/chai": "^4.1.2",
+		"@types/mocha": "^5.0.0",
+		"@types/node": "^14.14.10",
+		"babel-plugin-istanbul": "^6.0.0",
+		"babel-plugin-transform-async-to-promises": "^0.8.15",
+		"babel-plugin-transform-rename-properties": "0.1.0",
+		"benchmark": "^2.1.4",
+		"chai": "^4.1.2",
+		"check-export-map": "^1.0.1",
+		"coveralls": "^3.0.0",
+		"cross-env": "^7.0.2",
+		"csstype": "^3.0.5",
+		"diff": "^5.0.0",
+		"errorstacks": "^2.3.0",
+		"esbuild": "^0.8.47",
+		"eslint": "5.15.1",
+		"eslint-config-developit": "^1.1.1",
+		"eslint-config-prettier": "^6.5.0",
+		"eslint-plugin-react": "7.12.4",
+		"husky": "^4.3.0",
+		"karma": "^5.2.3",
+		"karma-chai-sinon": "^0.1.5",
+		"karma-chrome-launcher": "^3.1.0",
+		"karma-coverage": "^2.0.3",
+		"karma-esbuild": "^1.1.4",
+		"karma-mocha": "^2.0.1",
+		"karma-mocha-reporter": "^2.2.5",
+		"karma-sauce-launcher": "^4.3.4",
+		"karma-sinon": "^1.0.5",
+		"karma-sourcemap-loader": "^0.3.7",
+		"kolorist": "^1.2.10",
+		"lint-staged": "^10.5.2",
+		"lodash": "^4.17.20",
+		"microbundle": "^0.11.0",
+		"mocha": "^8.2.1",
+		"npm-merge-driver-install": "^1.1.1",
+		"npm-run-all": "^4.0.0",
+		"prettier": "^1.18.2",
+		"prop-types": "^15.7.2",
+		"sinon": "^9.2.3",
+		"sinon-chai": "^3.5.0",
+		"typescript": "3.5.3"
+	}
+
+,"_resolved": "https://registry.npmjs.org/preact/-/preact-10.5.13.tgz"
+,"_integrity": "sha512-q/vlKIGNwzTLu+jCcvywgGrt+H/1P/oIRSD6mV4ln3hmlC+Aa34C7yfPI4+5bzW8pONyVXYS7SvXosy2dKKtWQ=="
+,"_from": "preact@10.5.13"
+}

package/preact/src/cjs.js

@@ -0,0 +1,3 @@
+import * as preact from './index.js';
+if (typeof module < 'u') module.exports = preact;
+else self.preact = preact;

package/preact/src/clone-element.js

@@ -0,0 +1,39 @@
+import { assign } from './util';
+import { createVNode } from './create-element';
+
+/**
+ * Clones the given VNode, optionally adding attributes/props and replacing its children.
+ * @param {import('./internal').VNode} vnode The virtual DOM element to clone
+ * @param {object} props Attributes/props to add when cloning
+ * @param {Array<import('./internal').ComponentChildren>} rest Any additional arguments will be used as replacement children.
+ * @returns {import('./internal').VNode}
+ */
+export function cloneElement(vnode, props, children) {
+	let normalizedProps = assign({}, vnode.props),
+		key,
+		ref,
+		i;
+	for (i in props) {
+		if (i == 'key') key = props[i];
+		else if (i == 'ref') ref = props[i];
+		else normalizedProps[i] = props[i];
+	}
+
+	if (arguments.length > 3) {
+		children = [children];
+		for (i = 3; i < arguments.length; i++) {
+			children.push(arguments[i]);
+		}
+	}
+	if (children != null) {
+		normalizedProps.children = children;
+	}
+
+	return createVNode(
+		vnode.type,
+		normalizedProps,
+		key || vnode.key,
+		ref || vnode.ref,
+		null
+	);
+}

package/preact/src/component.js

@@ -0,0 +1,225 @@
+import { assign } from './util';
+import { diff, commitRoot } from './diff/index';
+import options from './options';
+import { Fragment } from './create-element';
+
+/**
+ * Base Component class. Provides `setState()` and `forceUpdate()`, which
+ * trigger rendering
+ * @param {object} props The initial component props
+ * @param {object} context The initial context from parent components'
+ * getChildContext
+ */
+export function Component(props, context) {
+	this.props = props;
+	this.context = context;
+}
+
+/**
+ * Update component state and schedule a re-render.
+ * @this {import('./internal').Component}
+ * @param {object | ((s: object, p: object) => object)} update A hash of state
+ * properties to update with new values or a function that given the current
+ * state and props returns a new partial state
+ * @param {() => void} [callback] A function to be called once component state is
+ * updated
+ */
+Component.prototype.setState = function(update, callback) {
+	// only clone state when copying to nextState the first time.
+	let s;
+	if (this._nextState != null && this._nextState !== this.state) {
+		s = this._nextState;
+	} else {
+		s = this._nextState = assign({}, this.state);
+	}
+
+	if (typeof update == 'function') {
+		// Some libraries like `immer` mark the current state as readonly,
+		// preventing us from mutating it, so we need to clone it. See #2716
+		update = update(assign({}, s), this.props);
+	}
+
+	if (update) {
+		assign(s, update);
+	}
+
+	// Skip update if updater function returned null
+	if (update == null) return;
+
+	if (this._vnode) {
+		if (callback) this._renderCallbacks.push(callback);
+		enqueueRender(this);
+	}
+};
+
+/**
+ * Immediately perform a synchronous re-render of the component
+ * @this {import('./internal').Component}
+ * @param {() => void} [callback] A function to be called after component is
+ * re-rendered
+ */
+Component.prototype.forceUpdate = function(callback) {
+	if (this._vnode) {
+		// Set render mode so that we can differentiate where the render request
+		// is coming from. We need this because forceUpdate should never call
+		// shouldComponentUpdate
+		this._force = true;
+		if (callback) this._renderCallbacks.push(callback);
+		enqueueRender(this);
+	}
+};
+
+/**
+ * Accepts `props` and `state`, and returns a new Virtual DOM tree to build.
+ * Virtual DOM is generally constructed via [JSX](http://jasonformat.com/wtf-is-jsx).
+ * @param {object} props Props (eg: JSX attributes) received from parent
+ * element/component
+ * @param {object} state The component's current state
+ * @param {object} context Context object, as returned by the nearest
+ * ancestor's `getChildContext()`
+ * @returns {import('./index').ComponentChildren | void}
+ */
+Component.prototype.render = Fragment;
+
+/**
+ * @param {import('./internal').VNode} vnode
+ * @param {number | null} [childIndex]
+ */
+export function getDomSibling(vnode, childIndex) {
+	if (childIndex == null) {
+		// Use childIndex==null as a signal to resume the search from the vnode's sibling
+		return vnode._parent
+			? getDomSibling(vnode._parent, vnode._parent._children.indexOf(vnode) + 1)
+			: null;
+	}
+
+	let sibling;
+	for (; childIndex < vnode._children.length; childIndex++) {
+		sibling = vnode._children[childIndex];
+
+		if (sibling != null && sibling._dom != null) {
+			// Since updateParentDomPointers keeps _dom pointer correct,
+			// we can rely on _dom to tell us if this subtree contains a
+			// rendered DOM node, and what the first rendered DOM node is
+			return sibling._dom;
+		}
+	}
+
+	// If we get here, we have not found a DOM node in this vnode's children.
+	// We must resume from this vnode's sibling (in it's parent _children array)
+	// Only climb up and search the parent if we aren't searching through a DOM
+	// VNode (meaning we reached the DOM parent of the original vnode that began
+	// the search)
+	return typeof vnode.type == 'function' ? getDomSibling(vnode) : null;
+}
+
+/**
+ * Trigger in-place re-rendering of a component.
+ * @param {import('./internal').Component} component The component to rerender
+ */
+function renderComponent(component) {
+	let vnode = component._vnode,
+		oldDom = vnode._dom,
+		parentDom = component._parentDom;
+
+	if (parentDom) {
+		let commitQueue = [];
+		const oldVNode = assign({}, vnode);
+		oldVNode._original = vnode._original + 1;
+
+		diff(
+			parentDom,
+			vnode,
+			oldVNode,
+			component._globalContext,
+			parentDom.ownerSVGElement !== undefined,
+			vnode._hydrating != null ? [oldDom] : null,
+			commitQueue,
+			oldDom == null ? getDomSibling(vnode) : oldDom,
+			vnode._hydrating
+		);
+		commitRoot(commitQueue, vnode);
+
+		if (vnode._dom != oldDom) {
+			updateParentDomPointers(vnode);
+		}
+	}
+}
+
+/**
+ * @param {import('./internal').VNode} vnode
+ */
+function updateParentDomPointers(vnode) {
+	if ((vnode = vnode._parent) != null && vnode._component != null) {
+		vnode._dom = vnode._component.base = null;
+		for (let i = 0; i < vnode._children.length; i++) {
+			let child = vnode._children[i];
+			if (child != null && child._dom != null) {
+				vnode._dom = vnode._component.base = child._dom;
+				break;
+			}
+		}
+
+		return updateParentDomPointers(vnode);
+	}
+}
+
+/**
+ * The render queue
+ * @type {Array<import('./internal').Component>}
+ */
+let rerenderQueue = [];
+
+/**
+ * Asynchronously schedule a callback
+ * @type {(cb: () => void) => void}
+ */
+/* istanbul ignore next */
+// Note the following line isn't tree-shaken by rollup cuz of rollup/rollup#2566
+const defer =
+	typeof Promise == 'function'
+		? Promise.prototype.then.bind(Promise.resolve())
+		: setTimeout;
+
+/*
+ * The value of `Component.debounce` must asynchronously invoke the passed in callback. It is
+ * important that contributors to Preact can consistently reason about what calls to `setState`, etc.
+ * do, and when their effects will be applied. See the links below for some further reading on designing
+ * asynchronous APIs.
+ * * [Designing APIs for Asynchrony](https://blog.izs.me/2013/08/designing-apis-for-asynchrony)
+ * * [Callbacks synchronous and asynchronous](https://blog.ometer.com/2011/07/24/callbacks-synchronous-and-asynchronous/)
+ */
+
+let prevDebounce;
+
+/**
+ * Enqueue a rerender of a component
+ * @param {import('./internal').Component} c The component to rerender
+ */
+export function enqueueRender(c) {
+	if (
+		(!c._dirty &&
+			(c._dirty = true) &&
+			rerenderQueue.push(c) &&
+			!process._rerenderCount++) ||
+		prevDebounce !== options.debounceRendering
+	) {
+		prevDebounce = options.debounceRendering;
+		(prevDebounce || defer)(process);
+	}
+}
+
+/** Flush the render queue by rerendering all queued components */
+function process() {
+	let queue;
+	while ((process._rerenderCount = rerenderQueue.length)) {
+		queue = rerenderQueue.sort((a, b) => a._vnode._depth - b._vnode._depth);
+		rerenderQueue = [];
+		// Don't update `renderCount` yet. Keep its value non-zero to prevent unnecessary
+		// process() calls from getting scheduled while `queue` is still being consumed.
+		queue.some(c => {
+			if (c._dirty) renderComponent(c);
+		});
+	}
+}
+process._rerenderCount = 0;

package/preact/src/constants.js

@@ -0,0 +1,3 @@
+export const EMPTY_OBJ = {};
+export const EMPTY_ARR = [];
+export const IS_NON_DIMENSIONAL = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i;