@bpmn-io/form-js-editor 1.0.0-alpha.0 → 1.0.0-alpha.10

package/dist/index.cjs

@@ -15,6 +15,25 @@ var feelers = require('feelers');
 var FeelEditor = require('@bpmn-io/feel-editor');
 var Big = require('big.js');
 
+function _interopNamespaceDefault(e) {
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
+
 var FN_REF = '__fn';
 var DEFAULT_PRIORITY$2 = 1000;
 var slice = Array.prototype.slice;
@@ -934,83 +953,91 @@ function useService$1 (type, strict) {
   return getService(type, strict);
 }
 
+var _path$3;
 function _extends$3() { _extends$3 = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$3.apply(this, arguments); }
-var CloseIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$3({
-  width: "16",
-  height: "16",
-  fill: "currentColor",
-  xmlns: "http://www.w3.org/2000/svg"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  clipRule: "evenodd",
-  d: "M12 4.7l-.7-.7L8 7.3 4.7 4l-.7.7L7.3 8 4 11.3l.7.7L8 8.7l3.3 3.3.7-.7L8.7 8 12 4.7z"
-})));
+var SvgClose = function SvgClose(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$3({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 16,
+    height: 16,
+    fill: "currentColor"
+  }, props), _path$3 || (_path$3 = /*#__PURE__*/React__namespace.createElement("path", {
+    fillRule: "evenodd",
+    d: "m12 4.7-.7-.7L8 7.3 4.7 4l-.7.7L7.3 8 4 11.3l.7.7L8 8.7l3.3 3.3.7-.7L8.7 8 12 4.7Z",
+    clipRule: "evenodd"
+  })));
+};
+var CloseIcon = SvgClose;
 
+var _path$2, _path2;
 function _extends$2() { _extends$2 = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$2.apply(this, arguments); }
-var DeleteIcon$1 = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$2({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "16",
-  height: "16",
-  fill: "none"
-}, props), /*#__PURE__*/React.createElement("rect", {
-  width: "16",
-  height: "16",
-  x: ".536",
-  fill: "#fff",
-  rx: "3",
-  style: {
-    mixBlendMode: "multiply"
-  }
-}), /*#__PURE__*/React.createElement("path", {
-  fill: "#fff",
-  d: "M.536 0h16v16h-16z",
-  style: {
-    mixBlendMode: "multiply"
-  }
-}), /*#__PURE__*/React.createElement("path", {
-  fill: "currentcolor",
-  d: "M7.536 6h-1v6h1V6zm3 0h-1v6h1V6z"
-}), /*#__PURE__*/React.createElement("path", {
-  fill: "currentcolor",
-  d: "M2.536 3v1h1v10a1 1 0 001 1h8a1 1 0 001-1V4h1V3h-12zm2 11V4h8v10h-8zm6-13h-4v1h4V1z"
-})));
+var SvgDelete = function SvgDelete(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$2({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 16,
+    height: 16,
+    fill: "none"
+  }, props), /*#__PURE__*/React__namespace.createElement("rect", {
+    width: 16,
+    height: 16,
+    x: 0.536,
+    fill: "#fff",
+    rx: 3,
+    style: {
+      mixBlendMode: "multiply"
+    }
+  }), /*#__PURE__*/React__namespace.createElement("path", {
+    fill: "#fff",
+    d: "M0 0h16v16H0z",
+    style: {
+      mixBlendMode: "multiply"
+    },
+    transform: "translate(.536)"
+  }), _path$2 || (_path$2 = /*#__PURE__*/React__namespace.createElement("path", {
+    fill: "currentcolor",
+    d: "M7.536 6h-1v6h1V6Zm3 0h-1v6h1V6Z"
+  })), _path2 || (_path2 = /*#__PURE__*/React__namespace.createElement("path", {
+    fill: "currentcolor",
+    d: "M2.536 3v1h1v10a1 1 0 0 0 1 1h8a1 1 0 0 0 1-1V4h1V3h-12Zm2 11V4h8v10h-8Zm6-13h-4v1h4V1Z"
+  })));
+};
+var DeleteIcon$1 = SvgDelete;
 
+var _path$1;
 function _extends$1() { _extends$1 = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends$1.apply(this, arguments); }
-var DraggableIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$1({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "16",
-  height: "16",
-  fill: "currentcolor",
-  viewBox: "0 0 32 32"
-}, props), /*#__PURE__*/React.createElement("path", {
-  d: "M10 6h4v4h-4zm8 0h4v4h-4zm-8 8h4v4h-4zm8 0h4v4h-4zm-8 8h4v4h-4zm8 0h4v4h-4z"
-}), /*#__PURE__*/React.createElement("path", {
-  d: "M0 0h32v32H0z",
-  fill: "none"
-})));
+var SvgDraggable = function SvgDraggable(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$1({
+    xmlns: "http://www.w3.org/2000/svg",
+    xmlSpace: "preserve",
+    width: 16,
+    height: 16,
+    fill: "currentcolor",
+    viewBox: "0 0 32 32"
+  }, props), _path$1 || (_path$1 = /*#__PURE__*/React__namespace.createElement("path", {
+    d: "M10 6h4v4h-4zm8 0h4v4h-4zm-8 8h4v4h-4zm8 0h4v4h-4zm-8 8h4v4h-4zm8 0h4v4h-4z"
+  })), /*#__PURE__*/React__namespace.createElement("path", {
+    d: "M0 0h32v32H0z",
+    style: {
+      fill: "none"
+    }
+  }));
+};
+var DraggableIcon = SvgDraggable;
 
+var _path;
 function _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }
-var SearchIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends({
-  width: "15",
-  height: "15",
-  fill: "none",
-  xmlns: "http://www.w3.org/2000/svg"
-}, props), /*#__PURE__*/React.createElement("path", {
-  d: "M14.5 13.793l-3.776-3.776a5.508 5.508 0 10-.707.707l3.776 3.776.707-.707zM2 6.5a4.5 4.5 0 119 0 4.5 4.5 0 01-9 0z",
-  fill: "currentColor"
-})));
+var SvgSearch = function SvgSearch(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 15,
+    height: 15,
+    fill: "none"
+  }, props), _path || (_path = /*#__PURE__*/React__namespace.createElement("path", {
+    fill: "currentColor",
+    d: "m14.5 13.793-3.776-3.776a5.508 5.508 0 1 0-.707.707l3.776 3.776.707-.707ZM2 6.5a4.5 4.5 0 1 1 9 0 4.5 4.5 0 0 1-9 0Z"
+  })));
+};
+var SearchIcon = SvgSearch;
 
 function EditorText(props) {
   const {
@@ -1071,6 +1098,228 @@ class EditorFormFields extends formJsViewer.FormFields {
   }
 }
 
+var ModularSection = (props => {
+  const {
+    rootClass,
+    RootElement,
+    section,
+    children
+  } = props;
+  const eventBus = useService$1('eventBus');
+  const sectionConfig = useService$1(`config.${section}`);
+  const [parent, setParent] = hooks.useState(sectionConfig && sectionConfig.parent || null);
+  const [shouldRender, setShouldRender] = hooks.useState(true);
+  const ParentElement = hooks.useMemo(() => {
+    if (parent === null) {
+      return null;
+    }
+    if (typeof parent === 'string') {
+      const element = document.querySelector(parent);
+      if (!element) {
+        throw new Error(`Target root element with selector '${parent}' not found for section '${section}'`);
+      }
+      return document.querySelector(parent);
+    }
+
+    // @ts-ignore
+    if (!(parent instanceof Element)) {
+      throw new Error(`Target root element for section '${section}' must be a valid selector or DOM element`);
+    }
+    return parent;
+  }, [section, parent]);
+  hooks.useEffect(() => {
+    const onAttach = ({
+      container
+    }) => {
+      setParent(container);
+      setShouldRender(true);
+    };
+    const onDetach = () => {
+      setParent(null);
+      setShouldRender(false);
+    };
+    const onReset = () => {
+      setParent(null);
+      setShouldRender(true);
+    };
+    eventBus.on(`${section}.attach`, onAttach);
+    eventBus.on(`${section}.detach`, onDetach);
+    eventBus.on(`${section}.reset`, onReset);
+    eventBus.fire(`${section}.section.rendered`);
+    return () => {
+      eventBus.off(`${section}.attach`, onAttach);
+      eventBus.off(`${section}.detach`, onDetach);
+      eventBus.off(`${section}.reset`, onReset);
+      eventBus.fire(`${section}.section.destroyed`);
+    };
+  }, [eventBus, section]);
+  hooks.useEffect(() => {
+    if (shouldRender) {
+      eventBus.fire(`${section}.rendered`, {
+        element: ParentElement
+      });
+      return () => {
+        eventBus.fire(`${section}.destroyed`, {
+          element: ParentElement
+        });
+      };
+    }
+  }, [eventBus, section, shouldRender, ParentElement]);
+  const Root = hooks.useCallback(({
+    children
+  }) => RootElement ? jsxRuntime.jsx(RootElement, {
+    children: children
+  }) : jsxRuntime.jsx("div", {
+    className: rootClass,
+    children: children
+  }), [rootClass, RootElement]);
+  return shouldRender ? parent ? React.createPortal(jsxRuntime.jsx(Root, {
+    children: children
+  }), ParentElement) : jsxRuntime.jsx(Root, {
+    children: children
+  }) : null;
+});
+
+const FillContext = preact.createContext({
+  addFill(uid, props) {
+    throw new Error('FillContext.addFill() uninitialized');
+  },
+  removeFill(uid) {
+    throw new Error('FillContext.addFill() uninitialized');
+  }
+});
+var FillContext$1 = FillContext;
+
+var Fill = (props => {
+  const uid = React.useRef(Symbol('fill_uid'));
+  const fillContext = React.useContext(FillContext$1);
+  React.useEffect(() => {
+    if (!fillContext) {
+      return;
+    }
+    fillContext.addFill({
+      id: uid,
+      ...props
+    });
+    return () => {
+      fillContext.removeFill(uid);
+    };
+  }, [fillContext, props]);
+  return null;
+});
+
+const SlotContext = preact.createContext({
+  fills: []
+});
+var SlotContext$1 = SlotContext;
+
+var Slot = (props => {
+  const {
+    name,
+    fillRoot = FillFragment,
+    groupFn = _groupByGroupName,
+    separatorFn = key => null,
+    limit
+  } = props;
+  const {
+    fills
+  } = hooks.useContext(SlotContext$1);
+  const filtered = hooks.useMemo(() => fills.filter(fill => fill.slot === name), [fills, name]);
+  const cropped = hooks.useMemo(() => limit ? filtered.slice(0, limit) : filtered, [filtered, limit]);
+  const groups = hooks.useMemo(() => groupFn(cropped), [cropped, groupFn]);
+  const fillsAndSeparators = hooks.useMemo(() => {
+    return buildFills(groups, fillRoot, separatorFn);
+  }, [groups, fillRoot, separatorFn]);
+  return fillsAndSeparators;
+});
+
+/**
+ * Creates a Fragment for a fill.
+ *
+ * @param {Object} fill Fill to be rendered
+ * @returns {Object} Preact Fragment containing fill's children
+ */
+const FillFragment = fill => jsxRuntime.jsx(preact.Fragment, {
+  children: fill.children
+}, fill.id);
+
+/**
+ * Creates an array of fills, with separators inserted between groups.
+ *
+ * @param {Array} groups Groups of fills
+ * @param {Function} fillRenderer Function to create a fill
+ * @param {Function} separatorRenderer Function to create a separator
+ * @returns {Array} Array of fills and separators
+ */
+const buildFills = (groups, fillRenderer, separatorRenderer) => {
+  const result = [];
+  groups.forEach((array, idx) => {
+    if (idx !== 0) {
+      const separator = separatorRenderer(`__separator_${idx}`);
+      if (separator) {
+        result.push(separator);
+      }
+    }
+    array.forEach(fill => {
+      result.push(fillRenderer(fill));
+    });
+  });
+  return result;
+};
+
+/**
+ * Groups fills by group name property.
+ */
+const _groupByGroupName = fills => {
+  const groups = [];
+  const groupsById = {};
+  fills.forEach(function (fill) {
+    const {
+      group: groupName = 'z_default'
+    } = fill;
+    let group = groupsById[groupName];
+    if (!group) {
+      groupsById[groupName] = group = [];
+      groups.push(group);
+    }
+    group.push(fill);
+  });
+  groups.forEach(group => group.sort(_comparePriority));
+  return Object.keys(groupsById).sort().map(id => groupsById[id]);
+};
+
+/**
+ * Compares fills by priority.
+ */
+const _comparePriority = (a, b) => {
+  return (b.priority || 0) - (a.priority || 0);
+};
+
+var SlotFillRoot = (props => {
+  const [fills, setFills] = hooks.useState([]);
+  const fillContext = hooks.useMemo(() => ({
+    addFill: fill => {
+      setFills(fills => [...fills.filter(f => f.id !== fill.id), fill]);
+      props.onSetFill && props.onSetFill(fill);
+    },
+    removeFill: id => {
+      setFills(fills => fills.filter(f => f.id !== id));
+      props.onRemoveFill && props.onRemoveFill(id);
+    }
+  }), []);
+  const slotContext = hooks.useMemo(() => ({
+    fills
+  }), [fills]);
+  return jsxRuntime.jsx(SlotContext$1.Provider, {
+    value: slotContext,
+    children: jsxRuntime.jsx(FillContext$1.Provider, {
+      /* @ts-expect-error */
+      value: fillContext,
+      children: props.children
+    })
+  });
+});
+
 const PALETTE_ENTRIES = formJsViewer.formFields.filter(({
   config: fieldConfig
 }) => fieldConfig.type !== 'default').map(({
@@ -1188,9 +1437,19 @@ function Palette(props) {
         class: "fjs-palette-no-entries",
         children: "No components found."
       })]
+    }), jsxRuntime.jsx("div", {
+      class: "fjs-palette-footer",
+      children: jsxRuntime.jsx(Slot, {
+        name: "editor-palette__footer",
+        fillRoot: FillRoot
+      })
     })]
   });
 }
+const FillRoot = fill => jsxRuntime.jsx("div", {
+  className: "fjs-palette-footer-fill",
+  children: fill.children
+});
 
 // helpers ///////
 
@@ -1217,6 +1476,25 @@ function getIndefiniteArticle(type) {
   return 'a';
 }
 
+var InjectedRendersRoot = (() => {
+  const renderInjector = useService$1('renderInjector');
+  const injectedRenderers = renderInjector.fetchRenderers();
+  const injectedProps = hooks.useMemo(() => ({
+    useService: useService$1,
+    components: {
+      Fill,
+      Slot
+    }
+  }), []);
+  return jsxRuntime.jsx(preact.Fragment, {
+    children: injectedRenderers.map(({
+      Renderer
+    }) => jsxRuntime.jsx(Renderer, {
+      ...injectedProps
+    }))
+  });
+});
+
 const CURSOR_CLS_PATTERN = /^fjs-cursor-.*$/;
 function set(mode) {
   const classes = minDom.classes(document.body);
@@ -1672,7 +1950,7 @@ function ContextPad(props) {
 function Empty(props) {
   return null;
 }
-function Element(props) {
+function Element$1(props) {
   const eventBus = useService$1('eventBus'),
     formEditor = useService$1('formEditor'),
     formFieldRegistry = useService$1('formFieldRegistry'),
@@ -1835,8 +2113,6 @@ function FormEditor$1(props) {
     formEditor = useService$1('formEditor'),
     injector = useService$1('injector'),
     selection = useService$1('selection'),
-    palette = useService$1('palette'),
-    paletteConfig = useService$1('config.palette'),
     propertiesPanel = useService$1('propertiesPanel'),
     propertiesPanelConfig = useService$1('config.propertiesPanel');
   const {
@@ -1847,7 +2123,6 @@ function FormEditor$1(props) {
     ariaLabel
   } = properties;
   const formContainerRef = hooks.useRef(null);
-  const paletteRef = hooks.useRef(null);
   const propertiesPanelRef = hooks.useRef(null);
   const [, setSelection] = hooks.useState(schema);
   hooks.useEffect(() => {
@@ -1908,7 +2183,7 @@ function FormEditor$1(props) {
       eventBus.off('drag.start', onDragStart);
       eventBus.off('drag.end', onDragEnd);
     };
-  }, []);
+  }, [dragging, eventBus]);
 
   // fire event after render to notify interested parties
   hooks.useEffect(() => {
@@ -1917,7 +2192,7 @@ function FormEditor$1(props) {
   const formRenderContext = {
     Children,
     Column,
-    Element,
+    Element: Element$1,
     Empty,
     Row
   };
@@ -1946,14 +2221,6 @@ function FormEditor$1(props) {
   const onSubmit = hooks.useCallback(() => {}, []);
   const onReset = hooks.useCallback(() => {}, []);
 
-  // attach default palette
-  const hasDefaultPalette = defaultPalette(paletteConfig);
-  hooks.useEffect(() => {
-    if (hasDefaultPalette) {
-      palette.attachTo(paletteRef.current);
-    }
-  }, [palette, paletteRef, hasDefaultPalette]);
-
   // attach default properties panel
   const hasDefaultPropertiesPanel = defaultPropertiesPanel(propertiesPanelConfig);
   hooks.useEffect(() => {
@@ -1961,31 +2228,38 @@ function FormEditor$1(props) {
       propertiesPanel.attachTo(propertiesPanelRef.current);
     }
   }, [propertiesPanelRef, propertiesPanel, hasDefaultPropertiesPanel]);
-  return jsxRuntime.jsxs("div", {
+  return jsxRuntime.jsx("div", {
     class: "fjs-form-editor",
-    children: [jsxRuntime.jsxs(DragAndDropContext$1.Provider, {
-      value: dragAndDropContext,
-      children: [hasDefaultPalette && jsxRuntime.jsx("div", {
-        class: "fjs-editor-palette-container",
-        ref: paletteRef
-      }), jsxRuntime.jsx("div", {
-        ref: formContainerRef,
-        class: "fjs-form-container",
-        children: jsxRuntime.jsx(formJsViewer.FormContext.Provider, {
-          value: formContext,
-          children: jsxRuntime.jsx(formJsViewer.FormRenderContext.Provider, {
-            value: formRenderContext,
-            children: jsxRuntime.jsx(formJsViewer.FormComponent, {
-              onSubmit: onSubmit,
-              onReset: onReset
+    children: jsxRuntime.jsxs(SlotFillRoot, {
+      children: [jsxRuntime.jsxs(DragAndDropContext$1.Provider, {
+        value: dragAndDropContext,
+        children: [jsxRuntime.jsx(ModularSection, {
+          rootClass: "fjs-palette-container",
+          section: "palette",
+          children: jsxRuntime.jsx(Palette, {})
+        }), jsxRuntime.jsx("div", {
+          ref: formContainerRef,
+          class: "fjs-form-container",
+          children: jsxRuntime.jsx(formJsViewer.FormContext.Provider, {
+            value: formContext,
+            children: jsxRuntime.jsx(formJsViewer.FormRenderContext.Provider, {
+              value: formRenderContext,
+              children: jsxRuntime.jsx(formJsViewer.FormComponent, {
+                onSubmit: onSubmit,
+                onReset: onReset
+              })
             })
           })
-        })
-      }), jsxRuntime.jsx(CreatePreview, {})]
-    }), hasDefaultPropertiesPanel && jsxRuntime.jsx("div", {
-      class: "fjs-editor-properties-container",
-      ref: propertiesPanelRef
-    })]
+        }), jsxRuntime.jsx(CreatePreview, {})]
+      }), hasDefaultPropertiesPanel && jsxRuntime.jsx("div", {
+        class: "fjs-editor-properties-container",
+        ref: propertiesPanelRef
+      }), jsxRuntime.jsx(ModularSection, {
+        rootClass: "fjs-render-injector-container",
+        section: "renderInjector",
+        children: jsxRuntime.jsx(InjectedRendersRoot, {})
+      })]
+    })
   });
 }
 function getFormFieldIndex(parent, formField) {
@@ -2052,15 +2326,12 @@ function CreatePreview(props) {
 
 // helper //////
 
-function defaultPalette(paletteConfig) {
-  return !(paletteConfig && paletteConfig.parent);
+function findPaletteEntry(type) {
+  return PALETTE_ENTRIES.find(entry => entry.type === type);
 }
 function defaultPropertiesPanel(propertiesPanelConfig) {
   return !(propertiesPanelConfig && propertiesPanelConfig.parent);
 }
-function findPaletteEntry(type) {
-  return PALETTE_ENTRIES.find(entry => entry.type === type);
-}
 
 class Renderer {
   constructor(renderConfig, eventBus, formEditor, injector) {
@@ -4202,69 +4473,80 @@ var SelectionModule = {
   selectionBehavior: ['type', SelectionBehavior]
 };
 
-class PaletteRenderer {
-  constructor(paletteConfig, eventBus) {
-    const {
-      parent
-    } = paletteConfig || {};
+/**
+ * Base class for sectionable UI modules.
+ *
+ * @property {EventBus} _eventBus - EventBus instance used for event handling.
+ * @property {string} managerType - Type of the render manager. Used to form event names.
+ *
+ * @class SectionModuleBase
+ */
+class SectionModuleBase {
+  /**
+   * Create a SectionModuleBase instance.
+   *
+   * @param {any} eventBus - The EventBus instance used for event handling.
+   * @param {string} sectionKey - The type of render manager. Used to form event names.
+   *
+   * @constructor
+   */
+  constructor(eventBus, sectionKey) {
     this._eventBus = eventBus;
-    this._container = minDom.domify('<div class="fjs-palette-container"></div>');
-    if (parent) {
-      this.attachTo(parent);
-    }
-    this._eventBus.once('formEditor.rendered', 500, () => {
-      this._render();
+    this._sectionKey = sectionKey;
+    this._eventBus.on(`${this._sectionKey}.section.rendered`, () => {
+      this.isSectionRendered = true;
+    });
+    this._eventBus.on(`${this._sectionKey}.section.destroyed`, () => {
+      this.isSectionRendered = false;
     });
   }
 
   /**
-   * Attach the palette to a parent node.
+   * Attach the managed section to a parent node.
    *
-   * @param {HTMLElement} container
+   * @param {HTMLElement} container - The parent node to attach to.
    */
   attachTo(container) {
-    if (!container) {
-      throw new Error('container required');
-    }
-    if (typeof container === 'string') {
-      container = minDom.query(container);
-    }
-
-    // (1) detach from old parent
-    this.detach();
-
-    // (2) append to parent container
-    container.appendChild(this._container);
-
-    // (3) notify interested parties
-    this._eventBus.fire('palette.attach');
+    this._onceSectionRendered(() => this._eventBus.fire(`${this._sectionKey}.attach`, {
+      container
+    }));
   }
 
   /**
-   * Detach the palette from its parent node.
+   * Detach the managed section from its parent node.
    */
   detach() {
-    const parentNode = this._container.parentNode;
-    if (parentNode) {
-      parentNode.removeChild(this._container);
-      this._eventBus.fire('palette.detach');
-    }
+    this._onceSectionRendered(() => this._eventBus.fire(`${this._sectionKey}.detach`));
   }
-  _render() {
-    preact.render(jsxRuntime.jsx(Palette, {}), this._container);
-    this._eventBus.fire('palette.rendered');
+
+  /**
+   * Reset the managed section to its initial state.
+   */
+  reset() {
+    this._onceSectionRendered(() => this._eventBus.fire(`${this._sectionKey}.reset`));
   }
-  _destroy() {
-    if (this._container) {
-      preact.render(null, this._container);
-      this._eventBus.fire('palette.destroyed');
+
+  /**
+   * Circumvents timing issues.
+   */
+  _onceSectionRendered(callback) {
+    if (this.isSectionRendered) {
+      callback();
+    } else {
+      this._eventBus.once(`${this._sectionKey}.section.rendered`, callback);
     }
   }
 }
-PaletteRenderer.$inject = ['config.palette', 'eventBus'];
+
+let PaletteModule$1 = class PaletteModule extends SectionModuleBase {
+  constructor(eventBus) {
+    super(eventBus, 'palette');
+  }
+};
+PaletteModule$1.$inject = ['eventBus'];
 
 var PaletteModule = {
-  palette: ['type', PaletteRenderer]
+  palette: ['type', PaletteModule$1]
 };
 
 var ArrowIcon = function ArrowIcon(props) {
@@ -5728,77 +6010,236 @@ function isEdited$7(node) {
 function prefixId$6(id) {
   return `bio-properties-panel-${id}`;
 }
-const noop$1 = () => {};
-function FeelTextfield(props) {
+function NumberField(props) {
   const {
     debounce,
+    disabled,
+    displayLabel = true,
     id,
+    inputRef,
     label,
+    max,
+    min,
     onInput,
-    onError,
-    feel,
+    step,
     value = '',
-    disabled = false,
-    variables,
-    tooltipContainer,
-    OptionalComponent = OptionalFeelInput
+    onFocus,
+    onBlur
   } = props;
-  const [localValue, _setLocalValue] = hooks.useState(value);
-  const editorRef = useShowEntryEvent(id);
-  const containerRef = hooks.useRef();
-  const feelActive = minDash.isString(localValue) && localValue.startsWith('=') || feel === 'required';
-  const feelOnlyValue = minDash.isString(localValue) && localValue.startsWith('=') ? localValue.substring(1) : localValue;
-  const [focus, _setFocus] = hooks.useState(undefined);
-  const setFocus = (offset = 0) => {
-    const hasFocus = containerRef.current.contains(document.activeElement);
-
-    // Keep caret position if it is already focused, otherwise focus at the end
-    const position = hasFocus ? document.activeElement.selectionStart : Infinity;
-    _setFocus(position + offset);
-  };
+  const [localValue, setLocalValue] = hooks.useState(value);
   const handleInputCallback = hooks.useMemo(() => {
-    return debounce(newValue => {
-      onInput(newValue);
+    return debounce(event => {
+      const {
+        validity,
+        value
+      } = event.target;
+      if (validity.valid) {
+        onInput(value ? parseFloat(value) : undefined);
+      }
     });
   }, [onInput, debounce]);
-  const setLocalValue = newValue => {
-    _setLocalValue(newValue);
-    if (!newValue || newValue === '=') {
-      handleInputCallback(undefined);
-    } else {
-      handleInputCallback(newValue);
-    }
-  };
-  const handleFeelToggle = useStaticCallback(() => {
-    if (feel === 'required') {
-      return;
-    }
-    if (!feelActive) {
-      setLocalValue('=' + localValue);
-    } else {
-      setLocalValue(feelOnlyValue);
-    }
-  });
-  const handleLocalInput = newValue => {
-    if (feelActive) {
-      newValue = '=' + newValue;
-    }
-    if (newValue === localValue) {
-      return;
-    }
-    setLocalValue(newValue);
-    if (!feelActive && minDash.isString(newValue) && newValue.startsWith('=')) {
-      // focus is behind `=` sign that will be removed
-      setFocus(-1);
-    }
+  const handleInput = e => {
+    handleInputCallback(e);
+    setLocalValue(e.target.value);
   };
-  const handleLint = useStaticCallback(lint => {
-    if (!(lint && lint.length)) {
-      onError(undefined);
+  hooks.useEffect(() => {
+    if (value === localValue) {
       return;
     }
-    const error = lint[0];
-    const message = `${error.source}: ${error.message}`;
+    setLocalValue(value);
+  }, [value]);
+  return jsxRuntime.jsxs("div", {
+    class: "bio-properties-panel-numberfield",
+    children: [displayLabel && jsxRuntime.jsx("label", {
+      for: prefixId$5(id),
+      class: "bio-properties-panel-label",
+      children: label
+    }), jsxRuntime.jsx("input", {
+      id: prefixId$5(id),
+      ref: inputRef,
+      type: "number",
+      name: id,
+      spellCheck: "false",
+      autoComplete: "off",
+      disabled: disabled,
+      class: "bio-properties-panel-input",
+      max: max,
+      min: min,
+      onInput: handleInput,
+      onFocus: onFocus,
+      onBlur: onBlur,
+      step: step,
+      value: localValue
+    })]
+  });
+}
+
+/**
+ * @param {Object} props
+ * @param {Boolean} props.debounce
+ * @param {String} props.description
+ * @param {Boolean} props.disabled
+ * @param {Object} props.element
+ * @param {Function} props.getValue
+ * @param {String} props.id
+ * @param {String} props.label
+ * @param {String} props.max
+ * @param {String} props.min
+ * @param {Function} props.setValue
+ * @param {Function} props.onFocus
+ * @param {Function} props.onBlur
+ * @param {String} props.step
+ * @param {Function} props.validate
+ */
+function NumberFieldEntry(props) {
+  const {
+    debounce,
+    description,
+    disabled,
+    element,
+    getValue,
+    id,
+    label,
+    max,
+    min,
+    setValue,
+    step,
+    onFocus,
+    onBlur,
+    validate
+  } = props;
+  const [cachedInvalidValue, setCachedInvalidValue] = hooks.useState(null);
+  const globalError = useError(id);
+  const [localError, setLocalError] = hooks.useState(null);
+  let value = getValue(element);
+  const previousValue = usePrevious(value);
+  hooks.useEffect(() => {
+    if (minDash.isFunction(validate)) {
+      const newValidationError = validate(value) || null;
+      setLocalError(newValidationError);
+    }
+  }, [value]);
+  const onInput = newValue => {
+    let newValidationError = null;
+    if (minDash.isFunction(validate)) {
+      newValidationError = validate(newValue) || null;
+    }
+    if (newValidationError) {
+      setCachedInvalidValue(newValue);
+    } else {
+      setValue(newValue);
+    }
+    setLocalError(newValidationError);
+  };
+  if (previousValue === value && localError) {
+    value = cachedInvalidValue;
+  }
+  const error = globalError || localError;
+  return jsxRuntime.jsxs("div", {
+    class: classnames('bio-properties-panel-entry', error ? 'has-error' : ''),
+    "data-entry-id": id,
+    children: [jsxRuntime.jsx(NumberField, {
+      debounce: debounce,
+      disabled: disabled,
+      id: id,
+      label: label,
+      onFocus: onFocus,
+      onBlur: onBlur,
+      onInput: onInput,
+      max: max,
+      min: min,
+      step: step,
+      value: value
+    }, element), error && jsxRuntime.jsx("div", {
+      class: "bio-properties-panel-error",
+      children: error
+    }), jsxRuntime.jsx(Description$1, {
+      forId: id,
+      element: element,
+      value: description
+    })]
+  });
+}
+function isEdited$6(node) {
+  return node && !!node.value;
+}
+
+// helpers /////////////////
+
+function prefixId$5(id) {
+  return `bio-properties-panel-${id}`;
+}
+const noop$1 = () => {};
+function FeelTextfield(props) {
+  const {
+    debounce,
+    id,
+    label,
+    onInput,
+    onError,
+    feel,
+    value = '',
+    disabled = false,
+    variables,
+    tooltipContainer,
+    OptionalComponent = OptionalFeelInput
+  } = props;
+  const [localValue, _setLocalValue] = hooks.useState(value);
+  const editorRef = useShowEntryEvent(id);
+  const containerRef = hooks.useRef();
+  const feelActive = minDash.isString(localValue) && localValue.startsWith('=') || feel === 'required';
+  const feelOnlyValue = minDash.isString(localValue) && localValue.startsWith('=') ? localValue.substring(1) : localValue;
+  const [focus, _setFocus] = hooks.useState(undefined);
+  const setFocus = (offset = 0) => {
+    const hasFocus = containerRef.current.contains(document.activeElement);
+
+    // Keep caret position if it is already focused, otherwise focus at the end
+    const position = hasFocus ? document.activeElement.selectionStart : Infinity;
+    _setFocus(position + offset);
+  };
+  const handleInputCallback = hooks.useMemo(() => {
+    return debounce(newValue => {
+      onInput(newValue);
+    });
+  }, [onInput, debounce]);
+  const setLocalValue = newValue => {
+    _setLocalValue(newValue);
+    if (!newValue || newValue === '=') {
+      handleInputCallback(undefined);
+    } else {
+      handleInputCallback(newValue);
+    }
+  };
+  const handleFeelToggle = useStaticCallback(() => {
+    if (feel === 'required') {
+      return;
+    }
+    if (!feelActive) {
+      setLocalValue('=' + localValue);
+    } else {
+      setLocalValue(feelOnlyValue);
+    }
+  });
+  const handleLocalInput = newValue => {
+    if (feelActive) {
+      newValue = '=' + newValue;
+    }
+    if (newValue === localValue) {
+      return;
+    }
+    setLocalValue(newValue);
+    if (!feelActive && minDash.isString(newValue) && newValue.startsWith('=')) {
+      // focus is behind `=` sign that will be removed
+      setFocus(-1);
+    }
+  };
+  const handleLint = useStaticCallback(lint => {
+    if (!(lint && lint.length)) {
+      onError(undefined);
+      return;
+    }
+    const error = lint[0];
+    const message = `${error.source}: ${error.message}`;
     onError(message);
   });
   hooks.useEffect(() => {
@@ -5854,7 +6295,7 @@ function FeelTextfield(props) {
       'feel-active': feelActive
     }),
     children: [jsxRuntime.jsxs("label", {
-      for: prefixId$5(id),
+      for: prefixId$4(id),
       class: "bio-properties-panel-label",
       onClick: () => setFocus(),
       children: [label, jsxRuntime.jsx(FeelIcon, {
@@ -5871,7 +6312,7 @@ function FeelTextfield(props) {
         disabled: feel !== 'optional' || disabled,
         onClick: handleFeelToggle
       }), feelActive ? jsxRuntime.jsx(CodeEditor, {
-        id: prefixId$5(id),
+        id: prefixId$4(id),
         name: id,
         onInput: handleLocalInput,
         disabled: disabled,
@@ -5888,7 +6329,7 @@ function FeelTextfield(props) {
         ...props,
         onInput: handleLocalInput,
         contentAttributes: {
-          'id': prefixId$5(id),
+          'id': prefixId$4(id),
           'aria-label': label
         },
         value: localValue,
@@ -5926,7 +6367,7 @@ const OptionalFeelInput = React.forwardRef((props, ref) => {
     }
   };
   return jsxRuntime.jsx("input", {
-    id: prefixId$5(id),
+    id: prefixId$4(id),
     type: "text",
     ref: inputRef,
     name: id,
@@ -5940,6 +6381,53 @@ const OptionalFeelInput = React.forwardRef((props, ref) => {
     value: value || ''
   });
 });
+const OptionalFeelNumberField = React.forwardRef((props, ref) => {
+  const {
+    id,
+    debounce,
+    disabled,
+    onInput,
+    value,
+    min,
+    max,
+    step,
+    onFocus,
+    onBlur
+  } = props;
+  const inputRef = hooks.useRef();
+
+  // To be consistent with the FEEL editor, set focus at start of input
+  // this ensures clean editing experience when switching with the keyboard
+  ref.current = {
+    focus: position => {
+      const input = inputRef.current;
+      if (!input) {
+        return;
+      }
+      input.focus();
+      if (typeof position === 'number' && position !== Infinity) {
+        if (position > value.length) {
+          position = value.length;
+        }
+        input.setSelectionRange(position, position);
+      }
+    }
+  };
+  return jsxRuntime.jsx(NumberField, {
+    id: id,
+    debounce: debounce,
+    disabled: disabled,
+    displayLabel: false,
+    inputRef: inputRef,
+    max: max,
+    min: min,
+    onInput: onInput,
+    step: step,
+    value: value,
+    onFocus: onFocus,
+    onBlur: onBlur
+  });
+});
 React.forwardRef((props, ref) => {
   const {
     id,
@@ -5964,7 +6452,7 @@ React.forwardRef((props, ref) => {
     }
   };
   return jsxRuntime.jsx("textarea", {
-    id: prefixId$5(id),
+    id: prefixId$4(id),
     type: "text",
     ref: inputRef,
     name: id,
@@ -6040,7 +6528,7 @@ React.forwardRef((props, ref) => {
   };
   return jsxRuntime.jsx("input", {
     ref: inputRef,
-    id: prefixId$5(id),
+    id: prefixId$4(id),
     name: id,
     onFocus: onFocus,
     onBlur: onBlur,
@@ -6080,261 +6568,30 @@ function FeelEntry(props) {
     disabled,
     feel,
     label,
-    getValue,
-    setValue,
-    tooltipContainer,
-    hostLanguage,
-    singleLine,
-    validate,
-    show = noop$1,
-    example,
-    variables,
-    onFocus,
-    onBlur
-  } = props;
-  const [cachedInvalidValue, setCachedInvalidValue] = hooks.useState(null);
-  const [validationError, setValidationError] = hooks.useState(null);
-  const [localError, setLocalError] = hooks.useState(null);
-  let value = getValue(element);
-  const previousValue = usePrevious(value);
-  hooks.useEffect(() => {
-    if (minDash.isFunction(validate)) {
-      const newValidationError = validate(value) || null;
-      setValidationError(newValidationError);
-    }
-  }, [value]);
-  const onInput = useStaticCallback(newValue => {
-    let newValidationError = null;
-    if (minDash.isFunction(validate)) {
-      newValidationError = validate(newValue) || null;
-    }
-    if (newValidationError) {
-      setCachedInvalidValue(newValue);
-    } else {
-      // don't create multiple commandStack entries for the same value
-      if (newValue !== value) {
-        setValue(newValue);
-      }
-    }
-    setValidationError(newValidationError);
-  });
-  const onError = hooks.useCallback(err => {
-    setLocalError(err);
-  }, []);
-  if (previousValue === value && validationError) {
-    value = cachedInvalidValue;
-  }
-  const temporaryError = useError(id);
-  const error = localError || temporaryError || validationError;
-  return jsxRuntime.jsxs("div", {
-    class: classnames(props.class, 'bio-properties-panel-entry', error ? 'has-error' : ''),
-    "data-entry-id": id,
-    children: [jsxRuntime.jsx(FeelTextfield, {
-      debounce: debounce,
-      disabled: disabled,
-      feel: feel,
-      id: id,
-      label: label,
-      onInput: onInput,
-      onError: onError,
-      onFocus: onFocus,
-      onBlur: onBlur,
-      example: example,
-      hostLanguage: hostLanguage,
-      singleLine: singleLine,
-      show: show,
-      value: value,
-      variables: variables,
-      tooltipContainer: tooltipContainer,
-      OptionalComponent: props.OptionalComponent
-    }, element), error && jsxRuntime.jsx("div", {
-      class: "bio-properties-panel-error",
-      children: error
-    }), jsxRuntime.jsx(Description$1, {
-      forId: id,
-      element: element,
-      value: description
-    })]
-  });
-}
-
-/**
- * @param {Object} props
- * @param {Object} props.element
- * @param {String} props.id
- * @param {String} props.description
- * @param {Boolean} props.debounce
- * @param {Boolean} props.disabled
- * @param {Boolean} props.feel
- * @param {String} props.label
- * @param {Function} props.getValue
- * @param {Function} props.setValue
- * @param {Function} props.tooltipContainer
- * @param {Function} props.validate
- * @param {Function} props.show
- * @param {Function} props.example
- * @param {Function} props.variables
- * @param {Function} props.onFocus
- * @param {Function} props.onBlur
- */
-function FeelToggleSwitchEntry(props) {
-  return jsxRuntime.jsx(FeelEntry, {
-    class: "bio-properties-panel-feel-toggle-switch",
-    OptionalComponent: OptionalFeelToggleSwitch,
-    ...props
-  });
-}
-
-/**
- * @param {Object} props
- * @param {Object} props.element
- * @param {String} props.id
- * @param {String} props.description
- * @param {String} props.hostLanguage
- * @param {Boolean} props.singleLine
- * @param {Boolean} props.debounce
- * @param {Boolean} props.disabled
- * @param {Boolean} props.feel
- * @param {String} props.label
- * @param {Function} props.getValue
- * @param {Function} props.setValue
- * @param {Function} props.tooltipContainer
- * @param {Function} props.validate
- * @param {Function} props.show
- * @param {Function} props.example
- * @param {Function} props.variables
- * @param {Function} props.onFocus
- * @param {Function} props.onBlur
- */
-function FeelTemplatingEntry(props) {
-  return jsxRuntime.jsx(FeelEntry, {
-    class: "bio-properties-panel-feel-templating",
-    OptionalComponent: CodeEditor$1,
-    ...props
-  });
-}
-function isEdited$6(node) {
-  if (!node) {
-    return false;
-  }
-  if (node.type === 'checkbox') {
-    return !!node.checked || node.classList.contains('edited');
-  }
-  return !!node.value || node.classList.contains('edited');
-}
-
-// helpers /////////////////
-
-function prefixId$5(id) {
-  return `bio-properties-panel-${id}`;
-}
-function NumberField(props) {
-  const {
-    debounce,
-    disabled,
-    id,
-    label,
-    max,
-    min,
-    onInput,
-    step,
-    value = '',
-    onFocus,
-    onBlur
-  } = props;
-  const [localValue, setLocalValue] = hooks.useState(value);
-  const handleInputCallback = hooks.useMemo(() => {
-    return debounce(event => {
-      const {
-        validity,
-        value
-      } = event.target;
-      if (validity.valid) {
-        onInput(value ? parseFloat(value) : undefined);
-      }
-    });
-  }, [onInput, debounce]);
-  const handleInput = e => {
-    handleInputCallback(e);
-    setLocalValue(e.target.value);
-  };
-  hooks.useEffect(() => {
-    if (value === localValue) {
-      return;
-    }
-    setLocalValue(value);
-  }, [value]);
-  return jsxRuntime.jsxs("div", {
-    class: "bio-properties-panel-numberfield",
-    children: [jsxRuntime.jsx("label", {
-      for: prefixId$4(id),
-      class: "bio-properties-panel-label",
-      children: label
-    }), jsxRuntime.jsx("input", {
-      id: prefixId$4(id),
-      type: "number",
-      name: id,
-      spellCheck: "false",
-      autoComplete: "off",
-      disabled: disabled,
-      class: "bio-properties-panel-input",
-      max: max,
-      min: min,
-      onInput: handleInput,
-      onFocus: onFocus,
-      onBlur: onBlur,
-      step: step,
-      value: localValue
-    })]
-  });
-}
-
-/**
- * @param {Object} props
- * @param {Boolean} props.debounce
- * @param {String} props.description
- * @param {Boolean} props.disabled
- * @param {Object} props.element
- * @param {Function} props.getValue
- * @param {String} props.id
- * @param {String} props.label
- * @param {String} props.max
- * @param {String} props.min
- * @param {Function} props.setValue
- * @param {Function} props.onFocus
- * @param {Function} props.onBlur
- * @param {String} props.step
- * @param {Function} props.validate
- */
-function NumberFieldEntry(props) {
-  const {
-    debounce,
-    description,
-    disabled,
-    element,
-    getValue,
-    id,
-    label,
-    max,
-    min,
+    getValue,
     setValue,
-    step,
+    tooltipContainer,
+    hostLanguage,
+    singleLine,
+    validate,
+    show = noop$1,
+    example,
+    variables,
     onFocus,
-    onBlur,
-    validate
+    onBlur
   } = props;
   const [cachedInvalidValue, setCachedInvalidValue] = hooks.useState(null);
-  const globalError = useError(id);
+  const [validationError, setValidationError] = hooks.useState(null);
   const [localError, setLocalError] = hooks.useState(null);
   let value = getValue(element);
   const previousValue = usePrevious(value);
   hooks.useEffect(() => {
     if (minDash.isFunction(validate)) {
       const newValidationError = validate(value) || null;
-      setLocalError(newValidationError);
+      setValidationError(newValidationError);
     }
   }, [value]);
-  const onInput = newValue => {
+  const onInput = useStaticCallback(newValue => {
     let newValidationError = null;
     if (minDash.isFunction(validate)) {
       newValidationError = validate(newValue) || null;
@@ -6342,30 +6599,45 @@ function NumberFieldEntry(props) {
     if (newValidationError) {
       setCachedInvalidValue(newValue);
     } else {
-      setValue(newValue);
+      // don't create multiple commandStack entries for the same value
+      if (newValue !== value) {
+        setValue(newValue);
+      }
     }
-    setLocalError(newValidationError);
-  };
-  if (previousValue === value && localError) {
+    setValidationError(newValidationError);
+  });
+  const onError = hooks.useCallback(err => {
+    setLocalError(err);
+  }, []);
+  if (previousValue === value && validationError) {
     value = cachedInvalidValue;
   }
-  const error = globalError || localError;
+  const temporaryError = useError(id);
+  const error = localError || temporaryError || validationError;
   return jsxRuntime.jsxs("div", {
-    class: classnames('bio-properties-panel-entry', error ? 'has-error' : ''),
+    class: classnames(props.class, 'bio-properties-panel-entry', error ? 'has-error' : ''),
     "data-entry-id": id,
-    children: [jsxRuntime.jsx(NumberField, {
+    children: [preact.createElement(FeelTextfield, {
+      ...props,
       debounce: debounce,
       disabled: disabled,
+      feel: feel,
       id: id,
+      key: element,
       label: label,
+      onInput: onInput,
+      onError: onError,
       onFocus: onFocus,
       onBlur: onBlur,
-      onInput: onInput,
-      max: max,
-      min: min,
-      step: step,
-      value: value
-    }, element), error && jsxRuntime.jsx("div", {
+      example: example,
+      hostLanguage: hostLanguage,
+      singleLine: singleLine,
+      show: show,
+      value: value,
+      variables: variables,
+      tooltipContainer: tooltipContainer,
+      OptionalComponent: props.OptionalComponent
+    }), error && jsxRuntime.jsx("div", {
       class: "bio-properties-panel-error",
       children: error
     }), jsxRuntime.jsx(Description$1, {
@@ -6375,8 +6647,100 @@ function NumberFieldEntry(props) {
     })]
   });
 }
-function isEdited$4(node) {
-  return node && !!node.value;
+
+/**
+ * @param {Object} props
+ * @param {Object} props.element
+ * @param {String} props.id
+ * @param {String} props.description
+ * @param {Boolean} props.debounce
+ * @param {Boolean} props.disabled
+ * @param {String} props.max
+ * @param {String} props.min
+ * @param {String} props.step
+ * @param {Boolean} props.feel
+ * @param {String} props.label
+ * @param {Function} props.getValue
+ * @param {Function} props.setValue
+ * @param {Function} props.tooltipContainer
+ * @param {Function} props.validate
+ * @param {Function} props.show
+ * @param {Function} props.example
+ * @param {Function} props.variables
+ * @param {Function} props.onFocus
+ * @param {Function} props.onBlur
+ */
+function FeelNumberEntry(props) {
+  return jsxRuntime.jsx(FeelEntry, {
+    class: "bio-properties-panel-feel-number",
+    OptionalComponent: OptionalFeelNumberField,
+    ...props
+  });
+}
+
+/**
+ * @param {Object} props
+ * @param {Object} props.element
+ * @param {String} props.id
+ * @param {String} props.description
+ * @param {Boolean} props.debounce
+ * @param {Boolean} props.disabled
+ * @param {Boolean} props.feel
+ * @param {String} props.label
+ * @param {Function} props.getValue
+ * @param {Function} props.setValue
+ * @param {Function} props.tooltipContainer
+ * @param {Function} props.validate
+ * @param {Function} props.show
+ * @param {Function} props.example
+ * @param {Function} props.variables
+ * @param {Function} props.onFocus
+ * @param {Function} props.onBlur
+ */
+function FeelToggleSwitchEntry(props) {
+  return jsxRuntime.jsx(FeelEntry, {
+    class: "bio-properties-panel-feel-toggle-switch",
+    OptionalComponent: OptionalFeelToggleSwitch,
+    ...props
+  });
+}
+
+/**
+ * @param {Object} props
+ * @param {Object} props.element
+ * @param {String} props.id
+ * @param {String} props.description
+ * @param {String} props.hostLanguage
+ * @param {Boolean} props.singleLine
+ * @param {Boolean} props.debounce
+ * @param {Boolean} props.disabled
+ * @param {Boolean} props.feel
+ * @param {String} props.label
+ * @param {Function} props.getValue
+ * @param {Function} props.setValue
+ * @param {Function} props.tooltipContainer
+ * @param {Function} props.validate
+ * @param {Function} props.show
+ * @param {Function} props.example
+ * @param {Function} props.variables
+ * @param {Function} props.onFocus
+ * @param {Function} props.onBlur
+ */
+function FeelTemplatingEntry(props) {
+  return jsxRuntime.jsx(FeelEntry, {
+    class: "bio-properties-panel-feel-templating",
+    OptionalComponent: CodeEditor$1,
+    ...props
+  });
+}
+function isEdited$5(node) {
+  if (!node) {
+    return false;
+  }
+  if (node.type === 'checkbox') {
+    return !!node.checked || node.classList.contains('edited');
+  }
+  return !!node.value || node.classList.contains('edited');
 }
 
 // helpers /////////////////
@@ -7025,7 +7389,7 @@ function AltTextEntry(props) {
       component: AltText,
       editField: editField,
       field: field,
-      isEdited: isEdited$6
+      isEdited: isEdited$5
     });
   }
   return entries;
@@ -7047,7 +7411,7 @@ function AltText(props) {
   const setValue = value => {
     return editField(field, path, value);
   };
-  return FeelEntry({
+  return FeelTemplatingEntry({
     debounce,
     element: field,
     feel: 'optional',
@@ -7055,6 +7419,7 @@ function AltText(props) {
     id,
     label: 'Alternative text',
     setValue,
+    singleLine: true,
     variables
   });
 }
@@ -7143,7 +7508,7 @@ function DescriptionEntry(props) {
       component: Description,
       editField: editField,
       field: field,
-      isEdited: isEdited
+      isEdited: isEdited$5
     });
   }
   return entries;
@@ -7155,6 +7520,9 @@ function Description(props) {
     id
   } = props;
   const debounce = useService('debounce');
+  const variables = useVariables().map(name => ({
+    name
+  }));
   const path = ['description'];
   const getValue = () => {
     return minDash.get(field, path, '');
@@ -7162,13 +7530,15 @@ function Description(props) {
   const setValue = value => {
     return editField(field, path, value);
   };
-  return TextfieldEntry({
+  return FeelTemplatingEntry({
     debounce,
     element: field,
     getValue,
     id,
     label: 'Field description',
-    setValue
+    singleLine: true,
+    setValue,
+    variables
   });
 }
 
@@ -7587,127 +7957,129 @@ function Key$1(props) {
   });
 }
 
-function simpleStringEntryFactory(options) {
-  const {
-    id,
-    label,
-    path,
-    props
-  } = options;
+function LabelEntry(props) {
   const {
-    editField,
-    field
-  } = props;
-  return {
-    id,
-    label,
-    path,
     field,
-    editField,
-    component: SimpleStringComponent,
-    isEdited: isEdited
-  };
+    editField
+  } = props;
+  const {
+    type,
+    subtype
+  } = field;
+  const entries = [];
+  if (type === 'datetime') {
+    if (subtype === formJsViewer.DATETIME_SUBTYPES.DATE || subtype === formJsViewer.DATETIME_SUBTYPES.DATETIME) {
+      entries.push({
+        id: 'date-label',
+        component: DateLabel,
+        editField,
+        field,
+        isEdited: isEdited$5
+      });
+    }
+    if (subtype === formJsViewer.DATETIME_SUBTYPES.TIME || subtype === formJsViewer.DATETIME_SUBTYPES.DATETIME) {
+      entries.push({
+        id: 'time-label',
+        component: TimeLabel,
+        editField,
+        field,
+        isEdited: isEdited$5
+      });
+    }
+  } else if (INPUTS.includes(type) || type === 'button') {
+    entries.push({
+      id: 'label',
+      component: Label$1,
+      editField,
+      field,
+      isEdited: isEdited$5
+    });
+  }
+  return entries;
 }
-const SimpleStringComponent = props => {
+function Label$1(props) {
   const {
-    id,
-    label,
-    path,
+    editField,
     field,
-    editField
+    id
   } = props;
   const debounce = useService('debounce');
-  const getValue = () => minDash.get(field, path, '');
-  const setValue = value => editField(field, path, value);
-  return TextfieldEntry({
+  const variables = useVariables().map(name => ({
+    name
+  }));
+  const path = ['label'];
+  const getValue = () => {
+    return minDash.get(field, path, '');
+  };
+  const setValue = value => {
+    return editField(field, path, value);
+  };
+  return FeelTemplatingEntry({
     debounce,
     element: field,
     getValue,
     id,
-    label,
-    setValue
+    label: 'Field label',
+    singleLine: true,
+    setValue,
+    variables
   });
-};
-
-function simpleBoolEntryFactory(options) {
-  const {
-    id,
-    label,
-    description,
-    path,
-    props
-  } = options;
+}
+function DateLabel(props) {
   const {
     editField,
-    field
-  } = props;
-  return {
-    id,
-    label,
-    path,
     field,
-    editField,
-    description,
-    component: SimpleBoolComponent,
-    isEdited: isEdited$8
+    id
+  } = props;
+  const debounce = useService('debounce');
+  const variables = useVariables().map(name => ({
+    name
+  }));
+  const path = formJsViewer.DATE_LABEL_PATH;
+  const getValue = () => {
+    return minDash.get(field, path, '');
   };
+  const setValue = value => {
+    return editField(field, path, value);
+  };
+  return FeelTemplatingEntry({
+    debounce,
+    element: field,
+    getValue,
+    id,
+    label: 'Date label',
+    singleLine: true,
+    setValue,
+    variables
+  });
 }
-const SimpleBoolComponent = props => {
+function TimeLabel(props) {
   const {
-    id,
-    label,
-    path,
-    field,
     editField,
-    description
+    field,
+    id
   } = props;
-  const getValue = () => minDash.get(field, path, '');
-  const setValue = value => editField(field, path, value);
-  return CheckboxEntry({
+  const debounce = useService('debounce');
+  const variables = useVariables().map(name => ({
+    name
+  }));
+  const path = formJsViewer.TIME_LABEL_PATH;
+  const getValue = () => {
+    return minDash.get(field, path, '');
+  };
+  const setValue = value => {
+    return editField(field, path, value);
+  };
+  return FeelTemplatingEntry({
+    debounce,
     element: field,
     getValue,
     id,
-    label,
+    label: 'Time label',
+    singleLine: true,
     setValue,
-    description
+    variables
   });
-};
-
-function LabelEntry(props) {
-  const {
-    field
-  } = props;
-  const {
-    type,
-    subtype
-  } = field;
-  const entries = [];
-  if (type === 'datetime') {
-    if (subtype === formJsViewer.DATETIME_SUBTYPES.DATE || subtype === formJsViewer.DATETIME_SUBTYPES.DATETIME) {
-      entries.push(simpleStringEntryFactory({
-        id: 'date-label',
-        path: formJsViewer.DATE_LABEL_PATH,
-        label: 'Date label',
-        props
-      }));
-    }
-    if (subtype === formJsViewer.DATETIME_SUBTYPES.TIME || subtype === formJsViewer.DATETIME_SUBTYPES.DATETIME) {
-      entries.push(simpleStringEntryFactory({
-        id: 'time-label',
-        path: formJsViewer.TIME_LABEL_PATH,
-        label: 'Time label',
-        props
-      }));
-    }
-  } else if (INPUTS.includes(type) || type === 'button') {
-    entries.push(simpleStringEntryFactory({
-      id: 'label',
-      path: ['label'],
-      label: 'Field label',
-      props
-    }));
-  }
-  return entries;
 }
 
 function SourceEntry(props) {
@@ -7725,7 +8097,7 @@ function SourceEntry(props) {
       component: Source,
       editField: editField,
       field: field,
-      isEdited: isEdited$6
+      isEdited: isEdited$5
     });
   }
   return entries;
@@ -7747,7 +8119,7 @@ function Source(props) {
   const setValue = value => {
     return editField(field, path, value);
   };
-  return FeelEntry({
+  return FeelTemplatingEntry({
     debounce,
     description: 'Expression or static value (link/data URI)',
     element: field,
@@ -7756,6 +8128,7 @@ function Source(props) {
     id,
     label: 'Image source',
     setValue,
+    singleLine: true,
     variables
   });
 }
@@ -7780,7 +8153,7 @@ function TextEntry(props) {
     component: Text,
     editField: editField,
     field: field,
-    isEdited: isEdited$6
+    isEdited: isEdited$5
   }];
 
   // todo: skipped to make the release without too much risk
@@ -7849,7 +8222,7 @@ function NumberEntries(props) {
   entries.push({
     id: id + '-decimalDigits',
     component: NumberDecimalDigits,
-    isEdited: isEdited$4,
+    isEdited: isEdited$6,
     editField,
     field
   });
@@ -8216,6 +8589,50 @@ function TimeFormatSelect(props) {
   });
 }
 
+function simpleBoolEntryFactory(options) {
+  const {
+    id,
+    label,
+    description,
+    path,
+    props
+  } = options;
+  const {
+    editField,
+    field
+  } = props;
+  return {
+    id,
+    label,
+    path,
+    field,
+    editField,
+    description,
+    component: SimpleBoolComponent,
+    isEdited: isEdited$8
+  };
+}
+const SimpleBoolComponent = props => {
+  const {
+    id,
+    label,
+    path,
+    field,
+    editField,
+    description
+  } = props;
+  const getValue = () => minDash.get(field, path, '');
+  const setValue = value => editField(field, path, value);
+  return CheckboxEntry({
+    element: field,
+    getValue,
+    id,
+    label,
+    setValue,
+    description
+  });
+};
+
 function SelectEntries(props) {
   const {
     field
@@ -8436,6 +8853,34 @@ function updateKey(properties, oldKey, newKey) {
   }, {});
 }
 
+function AutoFocusSelectEntry(props) {
+  const {
+    autoFocusEntry,
+    element,
+    getValue
+  } = props;
+  const value = getValue(element);
+  const prevValue = usePrevious(value);
+  const eventBus = useService('eventBus');
+
+  // auto focus specifc other entry when selected value changed
+  hooks.useEffect(() => {
+    if (autoFocusEntry && prevValue && value !== prevValue) {
+      // @Note(pinussilvestrus): There is an issue in the properties
+      // panel so we have to wait a bit before showing the entry.
+      // Cf. https://github.com/camunda/linting/blob/4f5328e2722f73ae60ae584c5f576eaec3999cb2/lib/modeler/Linting.js#L37
+      setTimeout(() => {
+        eventBus.fire('propertiesPanel.showEntry', {
+          id: autoFocusEntry
+        });
+      });
+    }
+  }, [value, autoFocusEntry, prevValue, eventBus]);
+  return jsxRuntime.jsx(SelectEntry, {
+    ...props
+  });
+}
+
 function ValuesSourceSelectEntry(props) {
   const {
     editField,
@@ -8474,7 +8919,8 @@ function ValuesSourceSelect(props) {
       value: valueSource
     }));
   };
-  return SelectEntry({
+  return AutoFocusSelectEntry({
+    autoFocusEntry: getAutoFocusEntryId(field),
     label: 'Type',
     element: field,
     getOptions: getValuesSourceOptions,
@@ -8484,6 +8930,20 @@ function ValuesSourceSelect(props) {
   });
 }
 
+// helpers //////////
+
+function getAutoFocusEntryId(field) {
+  const valuesSource = formJsViewer.getValuesSource(field);
+  if (valuesSource === formJsViewer.VALUES_SOURCES.EXPRESSION) {
+    return `${field.id}-valuesExpression-expression`;
+  } else if (valuesSource === formJsViewer.VALUES_SOURCES.INPUT) {
+    return `${field.id}-dynamicValues-key`;
+  } else if (valuesSource === formJsViewer.VALUES_SOURCES.STATIC) {
+    return `${field.id}-staticValues-0-label`;
+  }
+  return null;
+}
+
 function InputKeyValuesSourceEntry(props) {
   const {
     editField,
@@ -8640,7 +9100,7 @@ function AdornerEntry(props) {
     entries.push({
       id: 'prefix-adorner',
       component: PrefixAdorner,
-      isEdited: isEdited,
+      isEdited: isEdited$5,
       editField,
       field,
       onChange,
@@ -8649,7 +9109,7 @@ function AdornerEntry(props) {
     entries.push({
       id: 'suffix-adorner',
       component: SuffixAdorner,
-      isEdited: isEdited,
+      isEdited: isEdited$5,
       editField,
       field,
       onChange,
@@ -8666,13 +9126,19 @@ function PrefixAdorner(props) {
     getValue
   } = props;
   const debounce = useService('debounce');
-  return TextfieldEntry({
+  const variables = useVariables().map(name => ({
+    name
+  }));
+  return FeelTemplatingEntry({
     debounce,
     element: field,
+    feel: 'optional',
     getValue: getValue('prefixAdorner'),
     id,
     label: 'Prefix',
-    setValue: onChange('prefixAdorner')
+    setValue: onChange('prefixAdorner'),
+    singleLine: true,
+    variables
   });
 }
 function SuffixAdorner(props) {
@@ -8683,13 +9149,18 @@ function SuffixAdorner(props) {
     getValue
   } = props;
   const debounce = useService('debounce');
-  return TextfieldEntry({
+  const variables = useVariables().map(name => ({
+    name
+  }));
+  return FeelTemplatingEntry({
     debounce,
     element: field,
     getValue: getValue('suffixAdorner'),
     id,
     label: 'Suffix',
-    setValue: onChange('suffixAdorner')
+    setValue: onChange('suffixAdorner'),
+    singleLine: true,
+    variables
   });
 }
 
@@ -8708,7 +9179,7 @@ function ReadonlyEntry(props) {
       component: Readonly,
       editField: editField,
       field: field,
-      isEdited: isEdited$6
+      isEdited: isEdited$5
     });
   }
   return entries;
@@ -8752,7 +9223,7 @@ function ConditionEntry(props) {
     component: Condition,
     editField: editField,
     field: field,
-    isEdited: isEdited$6
+    isEdited: isEdited$5
   }];
 }
 function Condition(props) {
@@ -8790,6 +9261,55 @@ function Condition(props) {
   });
 }
 
+function ValuesExpressionEntry(props) {
+  const {
+    editField,
+    field,
+    id
+  } = props;
+  return [{
+    id: id + '-expression',
+    component: ValuesExpression,
+    label: 'Values expression',
+    isEdited: isEdited$5,
+    editField,
+    field
+  }];
+}
+function ValuesExpression(props) {
+  const {
+    editField,
+    field,
+    id
+  } = props;
+  const debounce = useService('debounce');
+  const variables = useVariables().map(name => ({
+    name
+  }));
+  const path = formJsViewer.VALUES_SOURCES_PATHS[formJsViewer.VALUES_SOURCES.EXPRESSION];
+  const schema = '[\n  {\n    "label": "dollar",\n    "value": "$"\n  }\n]';
+  const description = jsxRuntime.jsxs("div", {
+    children: ["Define an expression to populate the options from.", jsxRuntime.jsx("br", {}), jsxRuntime.jsx("br", {}), "The expression may result in an array of simple values or alternatively follow this schema:", jsxRuntime.jsx("pre", {
+      children: jsxRuntime.jsx("code", {
+        children: schema
+      })
+    })]
+  });
+  const getValue = () => minDash.get(field, path, '');
+  const setValue = value => editField(field, path, value || '');
+  return FeelEntry({
+    debounce,
+    description,
+    element: field,
+    feel: 'required',
+    getValue,
+    id,
+    label: 'Options expression',
+    setValue,
+    variables
+  });
+}
+
 function GeneralGroup(field, editField, getService) {
   const entries = [...IdEntry({
     field,
@@ -8934,14 +9454,14 @@ function ValidationGroup(field, editField) {
       component: MinLength,
       getValue,
       field,
-      isEdited: isEdited$4,
+      isEdited: isEdited$5,
       onChange
     }, {
       id: 'maxLength',
       component: MaxLength,
       getValue,
       field,
-      isEdited: isEdited$4,
+      isEdited: isEdited$5,
       onChange
     });
   }
@@ -8961,14 +9481,14 @@ function ValidationGroup(field, editField) {
       component: Min,
       getValue,
       field,
-      isEdited: isEdited$4,
+      isEdited: isEdited$5,
       onChange
     }, {
       id: 'max',
       component: Max,
       getValue,
       field,
-      isEdited: isEdited$4,
+      isEdited: isEdited$5,
       onChange
     });
   }
@@ -9001,14 +9521,19 @@ function MinLength(props) {
     onChange
   } = props;
   const debounce = useService('debounce');
-  return NumberFieldEntry({
+  const variables = useVariables().map(name => ({
+    name
+  }));
+  return FeelNumberEntry({
     debounce,
     element: field,
+    feel: 'optional',
     getValue: getValue('minLength'),
     id,
     label: 'Minimum length',
     min: 0,
-    setValue: onChange('minLength')
+    setValue: onChange('minLength'),
+    variables
   });
 }
 function MaxLength(props) {
@@ -9019,14 +9544,19 @@ function MaxLength(props) {
     onChange
   } = props;
   const debounce = useService('debounce');
-  return NumberFieldEntry({
+  const variables = useVariables().map(name => ({
+    name
+  }));
+  return FeelNumberEntry({
     debounce,
     element: field,
+    feel: 'optional',
     getValue: getValue('maxLength'),
     id,
     label: 'Maximum length',
     min: 0,
-    setValue: onChange('maxLength')
+    setValue: onChange('maxLength'),
+    variables
   });
 }
 function Pattern(props) {
@@ -9054,14 +9584,19 @@ function Min(props) {
     onChange
   } = props;
   const debounce = useService('debounce');
-  return NumberFieldEntry({
+  const variables = useVariables().map(name => ({
+    name
+  }));
+  return FeelNumberEntry({
     debounce,
     element: field,
+    feel: 'optional',
     id,
     label: 'Minimum',
     step: 'any',
     getValue: getValue('min'),
-    setValue: onChange('min')
+    setValue: onChange('min'),
+    variables
   });
 }
 function Max(props) {
@@ -9072,14 +9607,19 @@ function Max(props) {
     onChange
   } = props;
   const debounce = useService('debounce');
-  return NumberFieldEntry({
+  const variables = useVariables().map(name => ({
+    name
+  }));
+  return FeelNumberEntry({
     debounce,
     element: field,
+    feel: 'optional',
     id,
     label: 'Maximum',
     step: 'any',
     getValue: getValue('max'),
-    setValue: onChange('max')
+    setValue: onChange('max'),
+    variables
   });
 }
 function ValidationType(props) {
@@ -9153,6 +9693,17 @@ function ValuesGroups(field, editField) {
         id: staticValuesId
       })
     });
+  } else if (valuesSource === formJsViewer.VALUES_SOURCES.EXPRESSION) {
+    const valuesExpressionId = `${fieldId}-valuesExpression`;
+    groups.push({
+      id: valuesExpressionId,
+      label: 'Options expression',
+      component: Group,
+      entries: ValuesExpressionEntry({
+        ...context,
+        id: valuesExpressionId
+      })
+    });
   }
   return groups;
 }
@@ -9312,47 +9863,37 @@ function FormPropertiesPanel(props) {
   } = props;
   const formEditor = injector.get('formEditor');
   const modeling = injector.get('modeling');
-  const selection = injector.get('selection');
-  const {
-    schema
-  } = formEditor._getState();
+  const selectionModule = injector.get('selection');
   const [state, setState] = hooks.useState({
-    selectedFormField: selection.get() || schema
+    selectedFormField: selectionModule.get() || formEditor._getState().schema
   });
-  const _update = field => {
+  const selectedFormField = state.selectedFormField;
+  const refresh = hooks.useCallback(field => {
+    // TODO(skaiir): rework state management, re-rendering the whole properties panel is not the way to go
+    // https://github.com/bpmn-io/form-js/issues/686
     setState({
-      ...state,
-      selectedFormField: field
+      selectedFormField: selectionModule.get() || formEditor._getState().schema
     });
 
     // notify interested parties on property panel updates
     eventBus.fire('propertiesPanel.updated', {
       formField: field
     });
-  };
-  hooks.useLayoutEffect(() => {
-    function onSelectionChange(event) {
-      _update(event.selection || schema);
-    }
-    eventBus.on('selection.changed', onSelectionChange);
-    return () => {
-      eventBus.off('selection.changed', onSelectionChange);
-    };
-  }, []);
+  }, [eventBus, formEditor, selectionModule]);
   hooks.useLayoutEffect(() => {
-    const onFieldChanged = () => {
-      /**
-       * TODO(pinussilvestrus): update with actual updated element,
-       * once we have a proper updater/change support
-       */
-      _update(selection.get() || schema);
-    };
-    eventBus.on('changed', onFieldChanged);
+    /**
+     * TODO(pinussilvestrus): update with actual updated element,
+     * once we have a proper updater/change support
+     */
+    eventBus.on('changed', refresh);
+    eventBus.on('import.done', refresh);
+    eventBus.on('selection.changed', refresh);
     return () => {
-      eventBus.off('changed', onFieldChanged);
+      eventBus.off('changed', refresh);
+      eventBus.off('import.done', refresh);
+      eventBus.off('selection.changed', refresh);
     };
-  }, []);
-  const selectedFormField = state.selectedFormField;
+  }, [eventBus, refresh]);
   const getService = (type, strict = true) => injector.get(type, strict);
   const propertiesPanelContext = {
     getService
@@ -9448,10 +9989,70 @@ var PropertiesPanelModule = {
   propertiesPanel: ['type', PropertiesPanelRenderer]
 };
 
+/**
+ * Manages the rendering of visual plugins.
+ * @constructor
+ * @param {Object} eventBus - Event bus for the application.
+ */
+class RenderInjector extends SectionModuleBase {
+  constructor(eventBus) {
+    super(eventBus, 'renderInjector');
+    this._eventBus = eventBus;
+    this.registeredRenderers = [];
+  }
+
+  /**
+   * Inject a new renderer into the injector.
+   * @param {string} identifier - Identifier for the renderer.
+   * @param {Function} Renderer - The renderer function.
+   */
+  attachRenderer(identifier, Renderer) {
+    this.registeredRenderers = [...this.registeredRenderers, {
+      identifier,
+      Renderer
+    }];
+  }
+
+  /**
+   * Detach a renderer from the by key injector.
+   * @param {string} identifier - Identifier for the renderer.
+   */
+  detachRenderer(identifier) {
+    this.registeredRenderers = this.registeredRenderers.filter(r => r.identifier !== identifier);
+  }
+
+  /**
+   * Returns the registered renderers.
+   * @returns {Array} Array of registered renderers.
+   */
+  fetchRenderers() {
+    return this.registeredRenderers;
+  }
+}
+RenderInjector.$inject = ['eventBus'];
+
+var RenderInjectionModule = {
+  __init__: ['renderInjector'],
+  renderInjector: ['type', RenderInjector]
+};
+
+class EditorTemplating {
+  // same rules as viewer templating
+  isTemplate(value) {
+    return minDash.isString(value) && (value.startsWith('=') || /{{/.test(value));
+  }
+
+  // return the template raw, as we usually just want to display that
+  evaluate(template) {
+    return template;
+  }
+}
+EditorTemplating.$inject = [];
+
 var ExpressionLanguageModule = {
   __init__: ['expressionLanguage', 'templating'],
   expressionLanguage: ['type', formJsViewer.FeelExpressionLanguage],
-  templating: ['type', formJsViewer.FeelersTemplating]
+  templating: ['type', EditorTemplating]
 };
 
 const ids = new Ids([32, 36, 1]);
@@ -9706,7 +10307,7 @@ class FormEditor {
    * @internal
    */
   _getModules() {
-    return [ModelingModule, EditorActionsModule, DraggingModule, KeyboardModule, SelectionModule, PaletteModule, ExpressionLanguageModule, formJsViewer.MarkdownModule, PropertiesPanelModule];
+    return [ModelingModule, EditorActionsModule, DraggingModule, KeyboardModule, SelectionModule, PaletteModule, ExpressionLanguageModule, formJsViewer.MarkdownModule, PropertiesPanelModule, RenderInjectionModule];
   }
 
   /**