@bpmn-io/form-js-viewer 1.0.0-alpha.9 → 1.1.0

package/dist/index.es.js

@@ -1,27 +1,28 @@
 import Ids from 'ids';
-import { isString, isArray, isFunction, isNumber, bind, assign, isNil, groupBy, flatten, get, isUndefined, set, findIndex, isObject } from 'min-dash';
-import { parseExpressions, parseUnaryTests, evaluate, unaryTest } from 'feelin';
-import { evaluate as evaluate$1, parser, buildSimpleTree } from 'feelers';
-import showdown from 'showdown';
+import { isString, uniqueBy, isArray, get, set, isFunction, isNumber, bind, assign, isNil, groupBy, flatten, isUndefined, findIndex, isObject } from 'min-dash';
 import Big from 'big.js';
+import { parseExpression, parseUnaryTests, evaluate, unaryTest } from 'feelin';
+import { evaluate as evaluate$1, parser, buildSimpleTree } from 'feelers';
 import classNames from 'classnames';
 import { jsx, jsxs, Fragment as Fragment$1 } from 'preact/jsx-runtime';
-import { useContext, useMemo, useEffect, useState, useRef, useCallback } from 'preact/hooks';
+import { useContext, useMemo, useEffect, useState, useRef, useCallback, useLayoutEffect } from 'preact/hooks';
 import { createContext, createElement, Fragment, render } from 'preact';
-import React, { createPortal } from 'preact/compat';
+import * as React from 'preact/compat';
+import { createPortal } from 'preact/compat';
 import flatpickr from 'flatpickr';
 import Markup from 'preact-markup';
 import { Injector } from 'didi';
+import showdown from 'showdown';
 
-const getFlavouredFeelVariableNames = (feelString, feelFlavour, options = {}) => {
+const getFlavouredFeelVariableNames = (feelString, feelFlavour = 'expression', options = {}) => {
   const {
     depth = 0,
     specialDepthAccessors = {}
   } = options;
   if (!['expression', 'unaryTest'].includes(feelFlavour)) return [];
-  const tree = feelFlavour === 'expression' ? parseExpressions(feelString) : parseUnaryTests(feelString);
+  const tree = feelFlavour === 'expression' ? parseExpression(feelString) : parseUnaryTests(feelString);
   const simpleExpressionTree = _buildSimpleFeelStructureTree(tree, feelString);
-  return function _unfoldVariables(node) {
+  const variables = function _unfoldVariables(node) {
     if (node.name === 'PathExpression') {
       if (Object.keys(specialDepthAccessors).length === 0) {
         return depth === 0 ? [_getVariableNameAtPathIndex(node, 0)] : [];
@@ -34,34 +35,38 @@ const getFlavouredFeelVariableNames = (feelString, feelFlavour, options = {}) =>
 
     // for any other kind of node, traverse its children and flatten the result
     if (node.children) {
-      return node.children.reduce((acc, child) => {
+      const variables = node.children.reduce((acc, child) => {
         return acc.concat(_unfoldVariables(child));
       }, []);
+
+      // if we are within a filter context, we need to remove the item variable as it is used for iteration there
+      return node.name === 'FilterContext' ? variables.filter(name => name !== 'item') : variables;
     }
     return [];
   }(simpleExpressionTree);
+  return [...new Set(variables)];
 };
 
-/**
- * Get the variable name at the specified index in a given path expression.
- *
- * @param {Object} root - The root node of the path expression tree.
- * @param {number} index - The index of the variable name to retrieve.
- * @returns {string|null} The variable name at the specified index or null if index is out of bounds.
+/**
+ * Get the variable name at the specified index in a given path expression.
+ *
+ * @param {Object} root - The root node of the path expression tree.
+ * @param {number} index - The index of the variable name to retrieve.
+ * @returns {string|null} The variable name at the specified index or null if index is out of bounds.
  */
 const _getVariableNameAtPathIndex = (root, index) => {
   const accessors = _deconstructPathExpression(root);
   return accessors[index] || null;
 };
 
-/**
- * Extracts the variables which are required of the external context for a given path expression.
- * This is done by traversing the path expression tree and keeping track of the current depth relative to the external context.
- *
- * @param {Object} node - The root node of the path expression tree.
- * @param {number} initialDepth - The depth at which the root node is located in the outer context.
- * @param {Object} specialDepthAccessors - Definitions of special keywords which represent more complex accesses of the outer context.
- * @returns {Set} - A set containing the extracted variable names.
+/**
+ * Extracts the variables which are required of the external context for a given path expression.
+ * This is done by traversing the path expression tree and keeping track of the current depth relative to the external context.
+ *
+ * @param {Object} node - The root node of the path expression tree.
+ * @param {number} initialDepth - The depth at which the root node is located in the outer context.
+ * @param {Object} specialDepthAccessors - Definitions of special keywords which represent more complex accesses of the outer context.
+ * @returns {Set} - A set containing the extracted variable names.
  */
 const _smartExtractVariableNames = (node, initialDepth, specialDepthAccessors) => {
   // depth info represents the previous (initialised as null) and current depth of the current accessor in the path expression
@@ -107,11 +112,11 @@ const _smartExtractVariableNames = (node, initialDepth, specialDepthAccessors) =
   return new Set(extractedVariables);
 };
 
-/**
- * Deconstructs a path expression tree into an array of components.
- *
- * @param {Object} root - The root node of the path expression tree.
- * @returns {Array<string>} An array of components in the path expression, in the correct order.
+/**
+ * Deconstructs a path expression tree into an array of components.
+ *
+ * @param {Object} root - The root node of the path expression tree.
+ * @returns {Array<string>} An array of components in the path expression, in the correct order.
  */
 const _deconstructPathExpression = root => {
   let node = root;
@@ -130,13 +135,13 @@ const _deconstructPathExpression = root => {
   return parts.reverse();
 };
 
-/**
- * Builds a simplified feel structure tree from the given parse tree and feel string.
- * The nodes follow this structure: `{ name: string, children: Array, variableName?: string }`
- *
- * @param {Object} parseTree - The parse tree generated by a parser.
- * @param {string} feelString - The feel string used for parsing.
- * @returns {Object} The simplified feel structure tree.
+/**
+ * Builds a simplified feel structure tree from the given parse tree and feel string.
+ * The nodes follow this structure: `{ name: string, children: Array, variableName?: string }`
+ *
+ * @param {Object} parseTree - The parse tree generated by a parser.
+ * @param {string} feelString - The feel string used for parsing.
+ * @returns {Object} The simplified feel structure tree.
  */
 const _buildSimpleFeelStructureTree = (parseTree, feelString) => {
   const stack = [{
@@ -159,7 +164,45 @@ const _buildSimpleFeelStructureTree = (parseTree, feelString) => {
       parent.children.push(result);
     }
   });
-  return stack[0].children[0];
+  return _extractFilterExpressions(stack[0].children[0]);
+};
+
+/**
+ * Restructure the tree in such a way to bring filters (which create new contexts) to the root of the tree.
+ * This is done to simplify the extraction of variables and match the context hierarchy.
+ */
+const _extractFilterExpressions = tree => {
+  const flattenedExpressionTree = {
+    name: 'Root',
+    children: [tree]
+  };
+  const iterate = node => {
+    if (node.children) {
+      for (let x = 0; x < node.children.length; x++) {
+        if (node.children[x].name === 'FilterExpression') {
+          const filterTarget = node.children[x].children[0];
+          const filterExpression = node.children[x].children[2];
+
+          // bypass the filter expression
+          node.children[x] = filterTarget;
+          const taggedFilterExpression = {
+            name: 'FilterContext',
+            children: [filterExpression]
+          };
+
+          // append the filter expression to the root
+          flattenedExpressionTree.children.push(taggedFilterExpression);
+
+          // recursively iterate the expression
+          iterate(filterExpression);
+        } else {
+          iterate(node.children[x]);
+        }
+      }
+    }
+  };
+  iterate(tree);
+  return flattenedExpressionTree;
 };
 
 class FeelExpressionLanguage {
@@ -167,25 +210,25 @@ class FeelExpressionLanguage {
     this._eventBus = eventBus;
   }
 
-  /**
-   * Determines if the given value is a FEEL expression.
-   *
-   * @param {any} value
-   * @returns {boolean}
-   *
+  /**
+   * Determines if the given value is a FEEL expression.
+   *
+   * @param {any} value
+   * @returns {boolean}
+   *
    */
   isExpression(value) {
     return isString(value) && value.startsWith('=');
   }
 
-  /**
-   * Retrieve variable names from a given FEEL expression.
-   *
-   * @param {string} expression
-   * @param {object} [options]
-   * @param {string} [options.type]
-   *
-   * @returns {string[]}
+  /**
+   * Retrieve variable names from a given FEEL expression.
+   *
+   * @param {string} expression
+   * @param {object} [options]
+   * @param {string} [options.type]
+   *
+   * @returns {string[]}
    */
   getVariableNames(expression, options = {}) {
     const {
@@ -200,13 +243,13 @@ class FeelExpressionLanguage {
     return getFlavouredFeelVariableNames(expression, type);
   }
 
-  /**
-   * Evaluate an expression.
-   *
-   * @param {string} expression
-   * @param {import('../../types').Data} [data]
-   *
-   * @returns {any}
+  /**
+   * Evaluate an expression.
+   *
+   * @param {string} expression
+   * @param {import('../../types').Data} [data]
+   *
+   * @returns {any}
    */
   evaluate(expression, data = {}) {
     if (!expression) {
@@ -231,23 +274,23 @@ FeelExpressionLanguage.$inject = ['eventBus'];
 class FeelersTemplating {
   constructor() {}
 
-  /**
-   * Determines if the given value is a feelers template.
-   *
-   * @param {any} value
-   * @returns {boolean}
-   *
+  /**
+   * Determines if the given value is a feelers template.
+   *
+   * @param {any} value
+   * @returns {boolean}
+   *
    */
   isTemplate(value) {
     return isString(value) && (value.startsWith('=') || /{{.*?}}/.test(value));
   }
 
-  /**
-   * Retrieve variable names from a given feelers template.
-   *
-   * @param {string} template
-   *
-   * @returns {string[]}
+  /**
+   * Retrieve variable names from a given feelers template.
+   *
+   * @param {string} template
+   *
+   * @returns {string[]}
    */
   getVariableNames(template) {
     if (!this.isTemplate(template)) {
@@ -273,17 +316,17 @@ class FeelersTemplating {
     }, []);
   }
 
-  /**
-   * Evaluate a template.
-   *
-   * @param {string} template
-   * @param {Object<string, any>} context
-   * @param {Object} options
-   * @param {boolean} [options.debug = false]
-   * @param {boolean} [options.strict = false]
-   * @param {Function} [options.buildDebugString]
-   *
-   * @returns
+  /**
+   * Evaluate a template.
+   *
+   * @param {string} template
+   * @param {Object<string, any>} context
+   * @param {Object} options
+   * @param {boolean} [options.debug = false]
+   * @param {boolean} [options.strict = false]
+   * @param {Function} [options.buildDebugString]
+   *
+   * @returns
    */
   evaluate(template, context = {}, options = {}) {
     const {
@@ -298,22 +341,22 @@ class FeelersTemplating {
     });
   }
 
-  /**
-  * @typedef {Object} ExpressionWithDepth
-  * @property {number} depth - The depth of the expression in the syntax tree.
-  * @property {string} expression - The extracted expression
+  /**
+  * @typedef {Object} ExpressionWithDepth
+  * @property {number} depth - The depth of the expression in the syntax tree.
+  * @property {string} expression - The extracted expression
   */
 
-  /**
-  * Extracts all feel expressions in the template along with their depth in the syntax tree.
-  * The depth is incremented for child expressions of loops to account for context drilling.
-   * @name extractExpressionsWithDepth
-  * @param {string} template - A feelers template string.
-  * @returns {Array<ExpressionWithDepth>} An array of objects, each containing the depth and the extracted expression.
-  *
-  * @example
-  * const template = "Hello {{user}}, you have:{{#loop items}}\n- {{amount}} {{name}}{{/loop}}.";
-  * const extractedExpressions = _extractExpressionsWithDepth(template);
+  /**
+  * Extracts all feel expressions in the template along with their depth in the syntax tree.
+  * The depth is incremented for child expressions of loops to account for context drilling.
+  * @name extractExpressionsWithDepth
+  * @param {string} template - A feelers template string.
+  * @returns {Array<ExpressionWithDepth>} An array of objects, each containing the depth and the extracted expression.
+  *
+  * @example
+  * const template = "Hello {{user}}, you have:{{#loop items}}\n- {{amount}} {{name}}{{/loop}}.";
+  * const extractedExpressions = _extractExpressionsWithDepth(template);
   */
   _extractExpressionsWithDepth(template) {
     // build simplified feelers syntax tree
@@ -344,9 +387,9 @@ class FeelersTemplating {
 }
 FeelersTemplating.$inject = [];
 
-/**
- * @typedef {object} Condition
- * @property {string} [hide]
+/**
+ * @typedef {object} Condition
+ * @property {string} [hide]
  */
 
 class ConditionChecker {
@@ -355,11 +398,11 @@ class ConditionChecker {
     this._eventBus = eventBus;
   }
 
-  /**
-   * For given data, remove properties based on condition.
-   *
-   * @param {Object<string, any>} properties
-   * @param {Object<string, any>} data
+  /**
+   * For given data, remove properties based on condition.
+   *
+   * @param {Object<string, any>} properties
+   * @param {Object<string, any>} data
    */
   applyConditions(properties, data = {}) {
     const conditions = this._getConditions();
@@ -378,13 +421,13 @@ class ConditionChecker {
     return newProperties;
   }
 
-  /**
-   * Check if given condition is met. Returns null for invalid/missing conditions.
-   *
-   * @param {string} condition
-   * @param {import('../../types').Data} [data]
-   *
-   * @returns {boolean|null}
+  /**
+   * Check if given condition is met. Returns null for invalid/missing conditions.
+   *
+   * @param {string} condition
+   * @param {import('../../types').Data} [data]
+   *
+   * @returns {boolean|null}
    */
   check(condition, data = {}) {
     if (!condition) {
@@ -405,12 +448,12 @@ class ConditionChecker {
     }
   }
 
-  /**
-   * Check if hide condition is met.
-   *
-   * @param {Condition} condition
-   * @param {Object<string, any>} data
-   * @returns {boolean}
+  /**
+   * Check if hide condition is met.
+   *
+   * @param {Condition} condition
+   * @param {Object<string, any>} data
+   * @returns {boolean}
    */
   _checkHideCondition(condition, data) {
     if (!condition.hide) {
@@ -419,55 +462,787 @@ class ConditionChecker {
     const result = this.check(condition.hide, data);
     return result === true;
   }
-  _getConditions() {
-    const formFields = this._formFieldRegistry.getAll();
-    return formFields.reduce((conditions, formField) => {
-      const {
-        key,
-        conditional: condition
-      } = formField;
-      if (key && condition) {
-        return [...conditions, {
-          key,
-          condition
-        }];
-      }
-      return conditions;
-    }, []);
+  _getConditions() {
+    const formFields = this._formFieldRegistry.getAll();
+    return formFields.reduce((conditions, formField) => {
+      const {
+        key,
+        conditional: condition
+      } = formField;
+      if (key && condition) {
+        return [...conditions, {
+          key,
+          condition
+        }];
+      }
+      return conditions;
+    }, []);
+  }
+}
+ConditionChecker.$inject = ['formFieldRegistry', 'eventBus'];
+
+var ExpressionLanguageModule = {
+  __init__: ['expressionLanguage', 'templating', 'conditionChecker'],
+  expressionLanguage: ['type', FeelExpressionLanguage],
+  templating: ['type', FeelersTemplating],
+  conditionChecker: ['type', ConditionChecker]
+};
+
+// bootstrap showdown to support github flavored markdown
+showdown.setFlavor('github');
+class MarkdownRenderer {
+  constructor() {
+    this._converter = new showdown.Converter();
+  }
+
+  /**
+   * Render markdown to HTML.
+   *
+   * @param {string} markdown - The markdown to render
+   *
+   * @returns {string} HTML
+   */
+  render(markdown) {
+    return this._converter.makeHtml(markdown);
+  }
+}
+MarkdownRenderer.$inject = [];
+
+var MarkdownModule = {
+  __init__: ['markdownRenderer'],
+  markdownRenderer: ['type', MarkdownRenderer]
+};
+
+/**
+ * @typedef {import('didi').Injector} Injector
+ *
+ * @typedef {import('../core/Types').ElementLike} ElementLike
+ *
+ * @typedef {import('../core/EventBus').default} EventBus
+ * @typedef {import('./CommandHandler').default} CommandHandler
+ *
+ * @typedef { any } CommandContext
+ * @typedef { {
+ *   new (...args: any[]) : CommandHandler
+ * } } CommandHandlerConstructor
+ * @typedef { {
+ *   [key: string]: CommandHandler;
+ * } } CommandHandlerMap
+ * @typedef { {
+ *   command: string;
+ *   context: any;
+ *   id?: any;
+ * } } CommandStackAction
+ * @typedef { {
+ *   actions: CommandStackAction[];
+ *   dirty: ElementLike[];
+ *   trigger: 'execute' | 'undo' | 'redo' | 'clear' | null;
+ *   atomic?: boolean;
+ * } } CurrentExecution
+ */
+
+/**
+ * A service that offers un- and redoable execution of commands.
+ *
+ * The command stack is responsible for executing modeling actions
+ * in a un- and redoable manner. To do this it delegates the actual
+ * command execution to {@link CommandHandler}s.
+ *
+ * Command handlers provide {@link CommandHandler#execute(ctx)} and
+ * {@link CommandHandler#revert(ctx)} methods to un- and redo a command
+ * identified by a command context.
+ *
+ *
+ * ## Life-Cycle events
+ *
+ * In the process the command stack fires a number of life-cycle events
+ * that other components to participate in the command execution.
+ *
+ *    * preExecute
+ *    * preExecuted
+ *    * execute
+ *    * executed
+ *    * postExecute
+ *    * postExecuted
+ *    * revert
+ *    * reverted
+ *
+ * A special event is used for validating, whether a command can be
+ * performed prior to its execution.
+ *
+ *    * canExecute
+ *
+ * Each of the events is fired as `commandStack.{eventName}` and
+ * `commandStack.{commandName}.{eventName}`, respectively. This gives
+ * components fine grained control on where to hook into.
+ *
+ * The event object fired transports `command`, the name of the
+ * command and `context`, the command context.
+ *
+ *
+ * ## Creating Command Handlers
+ *
+ * Command handlers should provide the {@link CommandHandler#execute(ctx)}
+ * and {@link CommandHandler#revert(ctx)} methods to implement
+ * redoing and undoing of a command.
+ *
+ * A command handler _must_ ensure undo is performed properly in order
+ * not to break the undo chain. It must also return the shapes that
+ * got changed during the `execute` and `revert` operations.
+ *
+ * Command handlers may execute other modeling operations (and thus
+ * commands) in their `preExecute(d)` and `postExecute(d)` phases. The command
+ * stack will properly group all commands together into a logical unit
+ * that may be re- and undone atomically.
+ *
+ * Command handlers must not execute other commands from within their
+ * core implementation (`execute`, `revert`).
+ *
+ *
+ * ## Change Tracking
+ *
+ * During the execution of the CommandStack it will keep track of all
+ * elements that have been touched during the command's execution.
+ *
+ * At the end of the CommandStack execution it will notify interested
+ * components via an 'elements.changed' event with all the dirty
+ * elements.
+ *
+ * The event can be picked up by components that are interested in the fact
+ * that elements have been changed. One use case for this is updating
+ * their graphical representation after moving / resizing or deletion.
+ *
+ * @see CommandHandler
+ *
+ * @param {EventBus} eventBus
+ * @param {Injector} injector
+ */
+function CommandStack(eventBus, injector) {
+  /**
+   * A map of all registered command handlers.
+   *
+   * @type {CommandHandlerMap}
+   */
+  this._handlerMap = {};
+
+  /**
+   * A stack containing all re/undoable actions on the diagram
+   *
+   * @type {CommandStackAction[]}
+   */
+  this._stack = [];
+
+  /**
+   * The current index on the stack
+   *
+   * @type {number}
+   */
+  this._stackIdx = -1;
+
+  /**
+   * Current active commandStack execution
+   *
+   * @type {CurrentExecution}
+   */
+  this._currentExecution = {
+    actions: [],
+    dirty: [],
+    trigger: null
+  };
+
+  /**
+   * @type {Injector}
+   */
+  this._injector = injector;
+
+  /**
+   * @type EventBus
+   */
+  this._eventBus = eventBus;
+
+  /**
+   * @type { number }
+   */
+  this._uid = 1;
+  eventBus.on(['diagram.destroy', 'diagram.clear'], function () {
+    this.clear(false);
+  }, this);
+}
+CommandStack.$inject = ['eventBus', 'injector'];
+
+/**
+ * Execute a command.
+ *
+ * @param {string} command The command to execute.
+ * @param {CommandContext} context The context with which to execute the command.
+ */
+CommandStack.prototype.execute = function (command, context) {
+  if (!command) {
+    throw new Error('command required');
+  }
+  this._currentExecution.trigger = 'execute';
+  const action = {
+    command: command,
+    context: context
+  };
+  this._pushAction(action);
+  this._internalExecute(action);
+  this._popAction();
+};
+
+/**
+ * Check whether a command can be executed.
+ *
+ * Implementors may hook into the mechanism on two ways:
+ *
+ *   * in event listeners:
+ *
+ *     Users may prevent the execution via an event listener.
+ *     It must prevent the default action for `commandStack.(<command>.)canExecute` events.
+ *
+ *   * in command handlers:
+ *
+ *     If the method {@link CommandHandler#canExecute} is implemented in a handler
+ *     it will be called to figure out whether the execution is allowed.
+ *
+ * @param {string} command The command to execute.
+ * @param {CommandContext} context The context with which to execute the command.
+ *
+ * @return {boolean} Whether the command can be executed with the given context.
+ */
+CommandStack.prototype.canExecute = function (command, context) {
+  const action = {
+    command: command,
+    context: context
+  };
+  const handler = this._getHandler(command);
+  let result = this._fire(command, 'canExecute', action);
+
+  // handler#canExecute will only be called if no listener
+  // decided on a result already
+  if (result === undefined) {
+    if (!handler) {
+      return false;
+    }
+    if (handler.canExecute) {
+      result = handler.canExecute(context);
+    }
+  }
+  return result;
+};
+
+/**
+ * Clear the command stack, erasing all undo / redo history.
+ *
+ * @param {boolean} [emit=true] Whether to fire an event. Defaults to `true`.
+ */
+CommandStack.prototype.clear = function (emit) {
+  this._stack.length = 0;
+  this._stackIdx = -1;
+  if (emit !== false) {
+    this._fire('changed', {
+      trigger: 'clear'
+    });
+  }
+};
+
+/**
+ * Undo last command(s)
+ */
+CommandStack.prototype.undo = function () {
+  let action = this._getUndoAction(),
+    next;
+  if (action) {
+    this._currentExecution.trigger = 'undo';
+    this._pushAction(action);
+    while (action) {
+      this._internalUndo(action);
+      next = this._getUndoAction();
+      if (!next || next.id !== action.id) {
+        break;
+      }
+      action = next;
+    }
+    this._popAction();
+  }
+};
+
+/**
+ * Redo last command(s)
+ */
+CommandStack.prototype.redo = function () {
+  let action = this._getRedoAction(),
+    next;
+  if (action) {
+    this._currentExecution.trigger = 'redo';
+    this._pushAction(action);
+    while (action) {
+      this._internalExecute(action, true);
+      next = this._getRedoAction();
+      if (!next || next.id !== action.id) {
+        break;
+      }
+      action = next;
+    }
+    this._popAction();
+  }
+};
+
+/**
+ * Register a handler instance with the command stack.
+ *
+ * @param {string} command Command to be executed.
+ * @param {CommandHandler} handler Handler to execute the command.
+ */
+CommandStack.prototype.register = function (command, handler) {
+  this._setHandler(command, handler);
+};
+
+/**
+ * Register a handler type with the command stack  by instantiating it and
+ * injecting its dependencies.
+ *
+ * @param {string} command Command to be executed.
+ * @param {CommandHandlerConstructor} handlerCls Constructor to instantiate a {@link CommandHandler}.
+ */
+CommandStack.prototype.registerHandler = function (command, handlerCls) {
+  if (!command || !handlerCls) {
+    throw new Error('command and handlerCls must be defined');
+  }
+  const handler = this._injector.instantiate(handlerCls);
+  this.register(command, handler);
+};
+
+/**
+ * @return {boolean}
+ */
+CommandStack.prototype.canUndo = function () {
+  return !!this._getUndoAction();
+};
+
+/**
+ * @return {boolean}
+ */
+CommandStack.prototype.canRedo = function () {
+  return !!this._getRedoAction();
+};
+
+// stack access  //////////////////////
+
+CommandStack.prototype._getRedoAction = function () {
+  return this._stack[this._stackIdx + 1];
+};
+CommandStack.prototype._getUndoAction = function () {
+  return this._stack[this._stackIdx];
+};
+
+// internal functionality //////////////////////
+
+CommandStack.prototype._internalUndo = function (action) {
+  const command = action.command,
+    context = action.context;
+  const handler = this._getHandler(command);
+
+  // guard against illegal nested command stack invocations
+  this._atomicDo(() => {
+    this._fire(command, 'revert', action);
+    if (handler.revert) {
+      this._markDirty(handler.revert(context));
+    }
+    this._revertedAction(action);
+    this._fire(command, 'reverted', action);
+  });
+};
+CommandStack.prototype._fire = function (command, qualifier, event) {
+  if (arguments.length < 3) {
+    event = qualifier;
+    qualifier = null;
+  }
+  const names = qualifier ? [command + '.' + qualifier, qualifier] : [command];
+  let result;
+  event = this._eventBus.createEvent(event);
+  for (const name of names) {
+    result = this._eventBus.fire('commandStack.' + name, event);
+    if (event.cancelBubble) {
+      break;
+    }
+  }
+  return result;
+};
+CommandStack.prototype._createId = function () {
+  return this._uid++;
+};
+CommandStack.prototype._atomicDo = function (fn) {
+  const execution = this._currentExecution;
+  execution.atomic = true;
+  try {
+    fn();
+  } finally {
+    execution.atomic = false;
+  }
+};
+CommandStack.prototype._internalExecute = function (action, redo) {
+  const command = action.command,
+    context = action.context;
+  const handler = this._getHandler(command);
+  if (!handler) {
+    throw new Error('no command handler registered for <' + command + '>');
+  }
+  this._pushAction(action);
+  if (!redo) {
+    this._fire(command, 'preExecute', action);
+    if (handler.preExecute) {
+      handler.preExecute(context);
+    }
+    this._fire(command, 'preExecuted', action);
+  }
+
+  // guard against illegal nested command stack invocations
+  this._atomicDo(() => {
+    this._fire(command, 'execute', action);
+    if (handler.execute) {
+      // actual execute + mark return results as dirty
+      this._markDirty(handler.execute(context));
+    }
+
+    // log to stack
+    this._executedAction(action, redo);
+    this._fire(command, 'executed', action);
+  });
+  if (!redo) {
+    this._fire(command, 'postExecute', action);
+    if (handler.postExecute) {
+      handler.postExecute(context);
+    }
+    this._fire(command, 'postExecuted', action);
+  }
+  this._popAction();
+};
+CommandStack.prototype._pushAction = function (action) {
+  const execution = this._currentExecution,
+    actions = execution.actions;
+  const baseAction = actions[0];
+  if (execution.atomic) {
+    throw new Error('illegal invocation in <execute> or <revert> phase (action: ' + action.command + ')');
+  }
+  if (!action.id) {
+    action.id = baseAction && baseAction.id || this._createId();
+  }
+  actions.push(action);
+};
+CommandStack.prototype._popAction = function () {
+  const execution = this._currentExecution,
+    trigger = execution.trigger,
+    actions = execution.actions,
+    dirty = execution.dirty;
+  actions.pop();
+  if (!actions.length) {
+    this._eventBus.fire('elements.changed', {
+      elements: uniqueBy('id', dirty.reverse())
+    });
+    dirty.length = 0;
+    this._fire('changed', {
+      trigger: trigger
+    });
+    execution.trigger = null;
+  }
+};
+CommandStack.prototype._markDirty = function (elements) {
+  const execution = this._currentExecution;
+  if (!elements) {
+    return;
+  }
+  elements = isArray(elements) ? elements : [elements];
+  execution.dirty = execution.dirty.concat(elements);
+};
+CommandStack.prototype._executedAction = function (action, redo) {
+  const stackIdx = ++this._stackIdx;
+  if (!redo) {
+    this._stack.splice(stackIdx, this._stack.length, action);
+  }
+};
+CommandStack.prototype._revertedAction = function (action) {
+  this._stackIdx--;
+};
+CommandStack.prototype._getHandler = function (command) {
+  return this._handlerMap[command];
+};
+CommandStack.prototype._setHandler = function (command, handler) {
+  if (!command || !handler) {
+    throw new Error('command and handler required');
+  }
+  if (this._handlerMap[command]) {
+    throw new Error('overriding handler for command <' + command + '>');
+  }
+  this._handlerMap[command] = handler;
+};
+
+/**
+ * @type { import('didi').ModuleDeclaration }
+ */
+var commandModule = {
+  commandStack: ['type', CommandStack]
+};
+
+// config  ///////////////////
+
+const MINUTES_IN_DAY = 60 * 24;
+const DATETIME_SUBTYPES = {
+  DATE: 'date',
+  TIME: 'time',
+  DATETIME: 'datetime'
+};
+const TIME_SERIALISING_FORMATS = {
+  UTC_OFFSET: 'utc_offset',
+  UTC_NORMALIZED: 'utc_normalized',
+  NO_TIMEZONE: 'no_timezone'
+};
+const DATETIME_SUBTYPES_LABELS = {
+  [DATETIME_SUBTYPES.DATE]: 'Date',
+  [DATETIME_SUBTYPES.TIME]: 'Time',
+  [DATETIME_SUBTYPES.DATETIME]: 'Date & Time'
+};
+const TIME_SERIALISINGFORMAT_LABELS = {
+  [TIME_SERIALISING_FORMATS.UTC_OFFSET]: 'UTC offset',
+  [TIME_SERIALISING_FORMATS.UTC_NORMALIZED]: 'UTC normalized',
+  [TIME_SERIALISING_FORMATS.NO_TIMEZONE]: 'No timezone'
+};
+const DATETIME_SUBTYPE_PATH = ['subtype'];
+const DATE_LABEL_PATH = ['dateLabel'];
+const DATE_DISALLOW_PAST_PATH = ['disallowPassedDates'];
+const TIME_LABEL_PATH = ['timeLabel'];
+const TIME_USE24H_PATH = ['use24h'];
+const TIME_INTERVAL_PATH = ['timeInterval'];
+const TIME_SERIALISING_FORMAT_PATH = ['timeSerializingFormat'];
+
+// config  ///////////////////
+
+const VALUES_SOURCES = {
+  STATIC: 'static',
+  INPUT: 'input',
+  EXPRESSION: 'expression'
+};
+const VALUES_SOURCE_DEFAULT = VALUES_SOURCES.STATIC;
+const VALUES_SOURCES_LABELS = {
+  [VALUES_SOURCES.STATIC]: 'Static',
+  [VALUES_SOURCES.INPUT]: 'Input data',
+  [VALUES_SOURCES.EXPRESSION]: 'Expression'
+};
+const VALUES_SOURCES_PATHS = {
+  [VALUES_SOURCES.STATIC]: ['values'],
+  [VALUES_SOURCES.INPUT]: ['valuesKey'],
+  [VALUES_SOURCES.EXPRESSION]: ['valuesExpression']
+};
+const VALUES_SOURCES_DEFAULTS = {
+  [VALUES_SOURCES.STATIC]: [{
+    label: 'Value',
+    value: 'value'
+  }],
+  [VALUES_SOURCES.INPUT]: '',
+  [VALUES_SOURCES.EXPRESSION]: '='
+};
+
+// helpers ///////////////////
+
+function getValuesSource(field) {
+  for (const source of Object.values(VALUES_SOURCES)) {
+    if (get(field, VALUES_SOURCES_PATHS[source]) !== undefined) {
+      return source;
+    }
+  }
+  return VALUES_SOURCE_DEFAULT;
+}
+
+function createInjector(bootstrapModules) {
+  const injector = new Injector(bootstrapModules);
+  injector.init();
+  return injector;
+}
+
+/**
+ * @param {string?} prefix
+ *
+ * @returns Element
+ */
+function createFormContainer(prefix = 'fjs') {
+  const container = document.createElement('div');
+  container.classList.add(`${prefix}-container`);
+  return container;
+}
+
+const EXPRESSION_PROPERTIES = ['alt', 'appearance.prefixAdorner', 'appearance.suffixAdorner', 'conditional.hide', 'description', 'label', 'source', 'readonly', 'text', 'validate.min', 'validate.max', 'validate.minLength', 'validate.maxLength', 'valuesExpression'];
+const TEMPLATE_PROPERTIES = ['alt', 'appearance.prefixAdorner', 'appearance.suffixAdorner', 'description', 'label', 'source', 'text'];
+function findErrors(errors, path) {
+  return errors[pathStringify(path)];
+}
+function isRequired(field) {
+  return field.required;
+}
+function pathParse(path) {
+  if (!path) {
+    return [];
+  }
+  return path.split('.').map(key => {
+    return isNaN(parseInt(key)) ? key : parseInt(key);
+  });
+}
+function pathsEqual(a, b) {
+  return a && b && a.length === b.length && a.every((value, index) => value === b[index]);
+}
+function pathStringify(path) {
+  if (!path) {
+    return '';
+  }
+  return path.join('.');
+}
+const indices = {};
+function generateIndexForType(type) {
+  if (type in indices) {
+    indices[type]++;
+  } else {
+    indices[type] = 1;
+  }
+  return indices[type];
+}
+function generateIdForType(type) {
+  return `${type}${generateIndexForType(type)}`;
+}
+
+/**
+ * @template T
+ * @param {T} data
+ * @param {(this: any, key: string, value: any) => any} [replacer]
+ * @return {T}
+ */
+function clone(data, replacer) {
+  return JSON.parse(JSON.stringify(data, replacer));
+}
+
+/**
+ * Parse the schema for input variables a form might make use of
+ *
+ * @param {any} schema
+ *
+ * @return {string[]}
+ */
+function getSchemaVariables(schema, options = {}) {
+  const {
+    expressionLanguage = new FeelExpressionLanguage(null),
+    templating = new FeelersTemplating(),
+    inputs = true,
+    outputs = true
+  } = options;
+  if (!schema.components) {
+    return [];
+  }
+  const variables = schema.components.reduce((variables, component) => {
+    const {
+      key,
+      valuesKey,
+      type
+    } = component;
+    if (['button'].includes(type)) {
+      return variables;
+    }
+
+    // collect bi-directional variables
+    if (inputs || outputs) {
+      if (key) {
+        variables = [...variables, key];
+      }
+    }
+
+    // collect input-only variables
+    if (inputs) {
+      if (valuesKey) {
+        variables = [...variables, valuesKey];
+      }
+      EXPRESSION_PROPERTIES.forEach(prop => {
+        const property = get(component, prop.split('.'));
+        if (property && expressionLanguage.isExpression(property)) {
+          const expressionVariables = expressionLanguage.getVariableNames(property, {
+            type: 'expression'
+          });
+          variables = [...variables, ...expressionVariables];
+        }
+      });
+      TEMPLATE_PROPERTIES.forEach(prop => {
+        const property = get(component, prop.split('.'));
+        if (property && !expressionLanguage.isExpression(property) && templating.isTemplate(property)) {
+          const templateVariables = templating.getVariableNames(property);
+          variables = [...variables, ...templateVariables];
+        }
+      });
+    }
+    return variables.filter(variable => variable !== undefined || variable !== null);
+  }, []);
+
+  // remove duplicates
+  return Array.from(new Set(variables));
+}
+
+class UpdateFieldValidationHandler {
+  constructor(form, validator) {
+    this._form = form;
+    this._validator = validator;
+  }
+  execute(context) {
+    const {
+      field,
+      value
+    } = context;
+    const {
+      _path
+    } = field;
+    const {
+      errors
+    } = this._form._getState();
+    context.oldErrors = clone(errors);
+    const fieldErrors = this._validator.validateField(field, value);
+    const updatedErrors = set(errors, [pathStringify(_path)], fieldErrors.length ? fieldErrors : undefined);
+    this._form._setState({
+      errors: updatedErrors
+    });
+  }
+  revert(context) {
+    this._form._setState({
+      errors: context.oldErrors
+    });
   }
 }
-ConditionChecker.$inject = ['formFieldRegistry', 'eventBus'];
+UpdateFieldValidationHandler.$inject = ['form', 'validator'];
 
-var ExpressionLanguageModule = {
-  __init__: ['expressionLanguage', 'templating', 'conditionChecker'],
-  expressionLanguage: ['type', FeelExpressionLanguage],
-  templating: ['type', FeelersTemplating],
-  conditionChecker: ['type', ConditionChecker]
-};
-
-// bootstrap showdown to support github flavored markdown
-showdown.setFlavor('github');
-class MarkdownRenderer {
-  constructor() {
-    this._converter = new showdown.Converter();
+class ViewerCommands {
+  constructor(commandStack, eventBus) {
+    this._commandStack = commandStack;
+    eventBus.on('form.init', () => {
+      this.registerHandlers();
+    });
   }
-
-  /**
-   * Render markdown to HTML.
-   *
-   * @param {string} markdown - The markdown to render
-   *
-   * @returns {string} HTML
-   */
-  render(markdown) {
-    return this._converter.makeHtml(markdown);
+  registerHandlers() {
+    Object.entries(this.getHandlers()).forEach(([id, handler]) => {
+      this._commandStack.registerHandler(id, handler);
+    });
+  }
+  getHandlers() {
+    return {
+      'formField.validation.update': UpdateFieldValidationHandler
+    };
+  }
+  updateFieldValidation(field, value) {
+    const context = {
+      field,
+      value
+    };
+    this._commandStack.execute('formField.validation.update', context);
   }
 }
-MarkdownRenderer.$inject = [];
+ViewerCommands.$inject = ['commandStack', 'eventBus'];
 
-var MarkdownModule = {
-  __init__: ['markdownRenderer'],
-  markdownRenderer: ['type', MarkdownRenderer]
+var ViewerCommandsModule = {
+  __depends__: [commandModule],
+  __init__: ['viewerCommands'],
+  viewerCommands: ['type', ViewerCommands]
 };
 
 var FN_REF = '__fn';
@@ -997,7 +1772,13 @@ function isNullEquivalentValue(value) {
 
 const EMAIL_PATTERN = /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/;
 const PHONE_PATTERN = /(\+|00)(297|93|244|1264|358|355|376|971|54|374|1684|1268|61|43|994|257|32|229|226|880|359|973|1242|387|590|375|501|1441|591|55|1246|673|975|267|236|1|61|41|56|86|225|237|243|242|682|57|269|238|506|53|5999|61|1345|357|420|49|253|1767|45|1809|1829|1849|213|593|20|291|212|34|372|251|358|679|500|33|298|691|241|44|995|44|233|350|224|590|220|245|240|30|1473|299|502|594|1671|592|852|504|385|509|36|62|44|91|246|353|98|964|354|972|39|1876|44|962|81|76|77|254|996|855|686|1869|82|383|965|856|961|231|218|1758|423|94|266|370|352|371|853|590|212|377|373|261|960|52|692|389|223|356|95|382|976|1670|258|222|1664|596|230|265|60|262|264|687|227|672|234|505|683|31|47|977|674|64|968|92|507|64|51|63|680|675|48|1787|1939|850|351|595|970|689|974|262|40|7|250|966|249|221|65|500|4779|677|232|503|378|252|508|381|211|239|597|421|386|46|268|1721|248|963|1649|235|228|66|992|690|993|670|676|1868|216|90|688|886|255|256|380|598|1|998|3906698|379|1784|58|1284|1340|84|678|681|685|967|27|260|263)(9[976]\d|8[987530]\d|6[987]\d|5[90]\d|42\d|3[875]\d|2[98654321]\d|9[8543210]|8[6421]|6[6543210]|5[87654321]|4[987654310]|3[9643210]|2[70]|7|1)\d{4,20}$/;
+const VALIDATE_FEEL_PROPERTIES = ['min', 'max', 'minLength', 'maxLength'];
 class Validator {
+  constructor(expressionLanguage, conditionChecker, form) {
+    this._expressionLanguage = expressionLanguage;
+    this._conditionChecker = conditionChecker;
+    this._form = form;
+  }
   validateField(field, value) {
     const {
       type,
@@ -1030,10 +1811,11 @@ class Validator {
     if (!validate) {
       return errors;
     }
-    if (validate.pattern && value && !new RegExp(validate.pattern).test(value)) {
-      errors = [...errors, `Field must match pattern ${validate.pattern}.`];
+    const evaluatedValidation = evaluateFEELValues(validate, this._expressionLanguage, this._conditionChecker, this._form);
+    if (evaluatedValidation.pattern && value && !new RegExp(evaluatedValidation.pattern).test(value)) {
+      errors = [...errors, `Field must match pattern ${evaluatedValidation.pattern}.`];
     }
-    if (validate.required) {
+    if (evaluatedValidation.required) {
       const isUncheckedCheckbox = type === 'checkbox' && value === false;
       const isUnsetValue = isNil(value) || value === '';
       const isEmptyMultiselect = Array.isArray(value) && value.length === 0;
@@ -1041,28 +1823,64 @@ class Validator {
         errors = [...errors, 'Field is required.'];
       }
     }
-    if ('min' in validate && (value || value === 0) && value < validate.min) {
-      errors = [...errors, `Field must have minimum value of ${validate.min}.`];
+    if ('min' in evaluatedValidation && (value || value === 0) && value < evaluatedValidation.min) {
+      errors = [...errors, `Field must have minimum value of ${evaluatedValidation.min}.`];
     }
-    if ('max' in validate && (value || value === 0) && value > validate.max) {
-      errors = [...errors, `Field must have maximum value of ${validate.max}.`];
+    if ('max' in evaluatedValidation && (value || value === 0) && value > evaluatedValidation.max) {
+      errors = [...errors, `Field must have maximum value of ${evaluatedValidation.max}.`];
     }
-    if ('minLength' in validate && value && value.trim().length < validate.minLength) {
-      errors = [...errors, `Field must have minimum length of ${validate.minLength}.`];
+    if ('minLength' in evaluatedValidation && value && value.trim().length < evaluatedValidation.minLength) {
+      errors = [...errors, `Field must have minimum length of ${evaluatedValidation.minLength}.`];
     }
-    if ('maxLength' in validate && value && value.trim().length > validate.maxLength) {
-      errors = [...errors, `Field must have maximum length of ${validate.maxLength}.`];
+    if ('maxLength' in evaluatedValidation && value && value.trim().length > evaluatedValidation.maxLength) {
+      errors = [...errors, `Field must have maximum length of ${evaluatedValidation.maxLength}.`];
     }
-    if ('validationType' in validate && value && validate.validationType === 'phone' && !PHONE_PATTERN.test(value)) {
+    if ('validationType' in evaluatedValidation && value && evaluatedValidation.validationType === 'phone' && !PHONE_PATTERN.test(value)) {
       errors = [...errors, 'Field must be a valid  international phone number. (e.g. +4930664040900)'];
     }
-    if ('validationType' in validate && value && validate.validationType === 'email' && !EMAIL_PATTERN.test(value)) {
+    if ('validationType' in evaluatedValidation && value && evaluatedValidation.validationType === 'email' && !EMAIL_PATTERN.test(value)) {
       errors = [...errors, 'Field must be a valid email.'];
     }
     return errors;
   }
 }
-Validator.$inject = [];
+Validator.$inject = ['expressionLanguage', 'conditionChecker', 'form'];
+
+// helpers //////////
+
+/**
+ * Helper function to evaluate optional FEEL validation values.
+ */
+function evaluateFEELValues(validate, expressionLanguage, conditionChecker, form) {
+  const evaluatedValidate = {
+    ...validate
+  };
+  VALIDATE_FEEL_PROPERTIES.forEach(property => {
+    const path = property.split('.');
+    const value = get(evaluatedValidate, path);
+
+    // mirroring FEEL evaluation of our hooks
+    if (!expressionLanguage || !expressionLanguage.isExpression(value)) {
+      return value;
+    }
+    const {
+      initialData,
+      data
+    } = form._getState();
+    const newData = conditionChecker ? conditionChecker.applyConditions(data, data) : data;
+    const filteredData = {
+      ...initialData,
+      ...newData
+    };
+    const evaluatedValue = expressionLanguage.evaluate(value, filteredData);
+
+    // replace validate property with evaluated value
+    if (evaluatedValue) {
+      set(evaluatedValidate, path, evaluatedValue);
+    }
+  });
+  return evaluatedValidate;
+}
 
 class FormFieldRegistry {
   constructor(eventBus) {
@@ -1113,23 +1931,23 @@ class FormFieldRegistry {
 }
 FormFieldRegistry.$inject = ['eventBus'];
 
-/**
- * @typedef { { id: String, components: Array<String> } } FormRow
- * @typedef { { formFieldId: String, rows: Array<FormRow> } } FormRows
+/**
+ * @typedef { { id: String, components: Array<String> } } FormRow
+ * @typedef { { formFieldId: String, rows: Array<FormRow> } } FormRows
  */
 
-/**
- * Maintains the Form layout in a given structure, for example
- *
- *  [
- *    {
- *      formFieldId: 'FormField_1',
- *      rows: [
- *        { id: 'Row_1', components: [ 'Text_1', 'Textdield_1', ... ]  }
- *      ]
- *    }
- *  ]
- *
+/**
+ * Maintains the Form layout in a given structure, for example
+ *
+ *  [
+ *    {
+ *      formFieldId: 'FormField_1',
+ *      rows: [
+ *        { id: 'Row_1', components: [ 'Text_1', 'Textdield_1', ... ]  }
+ *      ]
+ *    }
+ *  ]
+ *
  */
 class FormLayouter {
   constructor(eventBus) {
@@ -1139,8 +1957,8 @@ class FormLayouter {
     this._eventBus = eventBus;
   }
 
-  /**
-   * @param {FormRow} row
+  /**
+   * @param {FormRow} row
    */
   addRow(formFieldId, row) {
     let rowsPerComponent = this._rows.find(r => r.formFieldId === formFieldId);
@@ -1154,18 +1972,18 @@ class FormLayouter {
     rowsPerComponent.rows.push(row);
   }
 
-  /**
-   * @param {String} id
-   * @returns {FormRow}
+  /**
+   * @param {String} id
+   * @returns {FormRow}
    */
   getRow(id) {
     const rows = allRows(this._rows);
     return rows.find(r => r.id === id);
   }
 
-  /**
-   * @param {any} formField
-   * @returns {FormRow}
+  /**
+   * @param {any} formField
+   * @returns {FormRow}
    */
   getRowForField(formField) {
     return allRows(this._rows).find(r => {
@@ -1176,9 +1994,9 @@ class FormLayouter {
     });
   }
 
-  /**
-   * @param {String} formFieldId
-   * @returns { Array<FormRow> }
+  /**
+   * @param {String} formFieldId
+   * @returns { Array<FormRow> }
    */
   getRows(formFieldId) {
     const rowsForField = this._rows.find(r => formFieldId === r.formFieldId);
@@ -1188,15 +2006,15 @@ class FormLayouter {
     return rowsForField.rows;
   }
 
-  /**
-   * @returns {string}
+  /**
+   * @returns {string}
    */
   nextRowId() {
     return this._ids.nextPrefixed('Row_');
   }
 
-  /**
-   * @param {any} formField
+  /**
+   * @param {any} formField
    */
   calculateLayout(formField) {
     const {
@@ -1232,224 +2050,38 @@ class FormLayouter {
     // fire event to notify interested parties
     this._eventBus.fire('form.layoutCleared');
   }
-}
-FormLayouter.$inject = ['eventBus'];
-
-// helpers //////
-
-function groupByRow(components, ids) {
-  return groupBy(components, c => {
-    // mitigate missing row by creating new (handle legacy)
-    const {
-      layout
-    } = c;
-    if (!layout || !layout.row) {
-      return ids.nextPrefixed('Row_');
-    }
-    return layout.row;
-  });
-}
-
-/**
- * @param {Array<FormRows>} formRows
- * @returns {Array<FormRow>}
- */
-function allRows(formRows) {
-  return flatten(formRows.map(c => c.rows));
-}
-
-// config  ///////////////////
-
-const MINUTES_IN_DAY = 60 * 24;
-const DATETIME_SUBTYPES = {
-  DATE: 'date',
-  TIME: 'time',
-  DATETIME: 'datetime'
-};
-const TIME_SERIALISING_FORMATS = {
-  UTC_OFFSET: 'utc_offset',
-  UTC_NORMALIZED: 'utc_normalized',
-  NO_TIMEZONE: 'no_timezone'
-};
-const DATETIME_SUBTYPES_LABELS = {
-  [DATETIME_SUBTYPES.DATE]: 'Date',
-  [DATETIME_SUBTYPES.TIME]: 'Time',
-  [DATETIME_SUBTYPES.DATETIME]: 'Date & Time'
-};
-const TIME_SERIALISINGFORMAT_LABELS = {
-  [TIME_SERIALISING_FORMATS.UTC_OFFSET]: 'UTC offset',
-  [TIME_SERIALISING_FORMATS.UTC_NORMALIZED]: 'UTC normalized',
-  [TIME_SERIALISING_FORMATS.NO_TIMEZONE]: 'No timezone'
-};
-const DATETIME_SUBTYPE_PATH = ['subtype'];
-const DATE_LABEL_PATH = ['dateLabel'];
-const DATE_DISALLOW_PAST_PATH = ['disallowPassedDates'];
-const TIME_LABEL_PATH = ['timeLabel'];
-const TIME_USE24H_PATH = ['use24h'];
-const TIME_INTERVAL_PATH = ['timeInterval'];
-const TIME_SERIALISING_FORMAT_PATH = ['timeSerializingFormat'];
-
-// config  ///////////////////
-
-const VALUES_SOURCES = {
-  STATIC: 'static',
-  INPUT: 'input'
-};
-const VALUES_SOURCE_DEFAULT = VALUES_SOURCES.STATIC;
-const VALUES_SOURCES_LABELS = {
-  [VALUES_SOURCES.STATIC]: 'Static',
-  [VALUES_SOURCES.INPUT]: 'Input data'
-};
-const VALUES_SOURCES_PATHS = {
-  [VALUES_SOURCES.STATIC]: ['values'],
-  [VALUES_SOURCES.INPUT]: ['valuesKey']
-};
-const VALUES_SOURCES_DEFAULTS = {
-  [VALUES_SOURCES.STATIC]: [{
-    label: 'Value',
-    value: 'value'
-  }],
-  [VALUES_SOURCES.INPUT]: ''
-};
-
-// helpers ///////////////////
-
-function getValuesSource(field) {
-  for (const source of Object.values(VALUES_SOURCES)) {
-    if (get(field, VALUES_SOURCES_PATHS[source]) !== undefined) {
-      return source;
-    }
-  }
-  return VALUES_SOURCE_DEFAULT;
-}
-
-function createInjector(bootstrapModules) {
-  const injector = new Injector(bootstrapModules);
-  injector.init();
-  return injector;
-}
-
-/**
- * @param {string?} prefix
- *
- * @returns Element
- */
-function createFormContainer(prefix = 'fjs') {
-  const container = document.createElement('div');
-  container.classList.add(`${prefix}-container`);
-  return container;
-}
-
-const EXPRESSION_PROPERTIES = ['alt', 'description', 'label', 'source', 'readonly', 'text'];
-const TEMPLATE_PROPERTIES = ['description', 'label', 'text'];
-function findErrors(errors, path) {
-  return errors[pathStringify(path)];
-}
-function isRequired(field) {
-  return field.required;
-}
-function pathParse(path) {
-  if (!path) {
-    return [];
-  }
-  return path.split('.').map(key => {
-    return isNaN(parseInt(key)) ? key : parseInt(key);
-  });
-}
-function pathsEqual(a, b) {
-  return a && b && a.length === b.length && a.every((value, index) => value === b[index]);
-}
-function pathStringify(path) {
-  if (!path) {
-    return '';
-  }
-  return path.join('.');
-}
-const indices = {};
-function generateIndexForType(type) {
-  if (type in indices) {
-    indices[type]++;
-  } else {
-    indices[type] = 1;
-  }
-  return indices[type];
-}
-function generateIdForType(type) {
-  return `${type}${generateIndexForType(type)}`;
-}
-
-/**
- * @template T
- * @param {T} data
- * @param {(this: any, key: string, value: any) => any} [replacer]
- * @return {T}
- */
-function clone(data, replacer) {
-  return JSON.parse(JSON.stringify(data, replacer));
-}
-
-/**
- * Parse the schema for input variables a form might make use of
- *
- * @param {any} schema
- *
- * @return {string[]}
- */
-function getSchemaVariables(schema, expressionLanguage = new FeelExpressionLanguage(null), templating = new FeelersTemplating()) {
-  if (!schema.components) {
-    return [];
-  }
-  const variables = schema.components.reduce((variables, component) => {
-    const {
-      key,
-      valuesKey,
-      type,
-      conditional
-    } = component;
-    if (['button'].includes(type)) {
-      return variables;
-    }
-    if (key) {
-      variables = [...variables, key];
-    }
-    if (valuesKey) {
-      variables = [...variables, valuesKey];
-    }
-    if (conditional && conditional.hide) {
-      const conditionVariables = expressionLanguage.getVariableNames(conditional.hide, {
-        type: 'unaryTest'
-      });
-      variables = [...variables, ...conditionVariables];
+}
+FormLayouter.$inject = ['eventBus'];
+
+// helpers //////
+
+function groupByRow(components, ids) {
+  return groupBy(components, c => {
+    // mitigate missing row by creating new (handle legacy)
+    const {
+      layout
+    } = c;
+    if (!layout || !layout.row) {
+      return ids.nextPrefixed('Row_');
     }
-    EXPRESSION_PROPERTIES.forEach(prop => {
-      const property = component[prop];
-      if (property && expressionLanguage.isExpression(property)) {
-        const expressionVariables = expressionLanguage.getVariableNames(property, {
-          type: 'expression'
-        });
-        variables = [...variables, ...expressionVariables];
-      }
-    });
-    TEMPLATE_PROPERTIES.forEach(prop => {
-      const property = component[prop];
-      if (property && !expressionLanguage.isExpression(property) && templating.isTemplate(property)) {
-        const templateVariables = templating.getVariableNames(property);
-        variables = [...variables, ...templateVariables];
-      }
-    });
-    return variables;
-  }, []);
+    return layout.row;
+  });
+}
 
-  // remove duplicates
-  return Array.from(new Set(variables));
+/**
+ * @param {Array<FormRows>} formRows
+ * @returns {Array<FormRow>}
+ */
+function allRows(formRows) {
+  return flatten(formRows.map(c => c.rows));
 }
 
 class Importer {
-  /**
-   * @constructor
-   * @param { import('../core').FormFieldRegistry } formFieldRegistry
-   * @param { import('../render/FormFields').default } formFields
-   * @param { import('../core').FormLayouter } formLayouter
+  /**
+   * @constructor
+   * @param { import('../core').FormFieldRegistry } formFieldRegistry
+   * @param { import('../render/FormFields').default } formFields
+   * @param { import('../core').FormLayouter } formLayouter
    */
   constructor(formFieldRegistry, formFields, formLayouter) {
     this._formFieldRegistry = formFieldRegistry;
@@ -1457,15 +2089,15 @@ class Importer {
     this._formLayouter = formLayouter;
   }
 
-  /**
-   * Import schema adding `id`, `_parent` and `_path`
-   * information to each field and adding it to the
-   * form field registry.
-   *
-   * @param {any} schema
-   * @param {any} [data]
-   *
-   * @return { { warnings: Array<any>, schema: any, data: any } }
+  /**
+   * Import schema adding `id`, `_parent` and `_path`
+   * information to each field and adding it to the
+   * form field registry.
+   *
+   * @param {any} schema
+   * @param {any} [data]
+   *
+   * @return { { warnings: Array<any>, schema: any, data: any } }
    */
   importSchema(schema, data = {}) {
     // TODO: Add warnings - https://github.com/bpmn-io/form-js/issues/289
@@ -1486,11 +2118,11 @@ class Importer {
     }
   }
 
-  /**
-   * @param {any} formField
-   * @param {string} [parentId]
-   *
-   * @return {any} importedField
+  /**
+   * @param {any} formField
+   * @param {string} [parentId]
+   *
+   * @return {any} importedField
    */
   importFormField(formField, parentId) {
     const {
@@ -1541,10 +2173,10 @@ class Importer {
     });
   }
 
-  /**
-   * @param {Object} data
-   *
-   * @return {Object} initializedData
+  /**
+   * @param {Object} data
+   *
+   * @return {Object} initializedData
    */
   initializeFieldValues(data) {
     return this._formFieldRegistry.getAll().reduce((initializedData, formField) => {
@@ -1618,7 +2250,7 @@ function prefixId(id, formId) {
   return `fjs-form-${id}`;
 }
 
-const type$b = 'button';
+const type$c = 'button';
 function Button(props) {
   const {
     disabled,
@@ -1628,7 +2260,7 @@ function Button(props) {
     action = 'submit'
   } = field;
   return jsx("div", {
-    class: formFieldClasses(type$b),
+    class: formFieldClasses(type$c),
     children: jsx("button", {
       class: "fjs-button",
       type: action,
@@ -1638,7 +2270,7 @@ function Button(props) {
   });
 }
 Button.config = {
-  type: type$b,
+  type: type$c,
   keyed: true,
   label: 'Button',
   group: 'action',
@@ -1682,11 +2314,11 @@ const FormRenderContext = createContext({
 });
 var FormRenderContext$1 = FormRenderContext;
 
-/**
- * @param {string} type
- * @param {boolean} [strict]
- *
- * @returns {any}
+/**
+ * @param {string} type
+ * @param {boolean} [strict]
+ *
+ * @returns {any}
  */
 function getService(type, strict) {}
 const FormContext = createContext({
@@ -1702,10 +2334,10 @@ function useService(type, strict) {
   return getService(type, strict);
 }
 
-/**
- * Returns the conditionally filtered data of a form reactively.
- * Memoised to minimize re-renders
- *
+/**
+ * Returns the conditionally filtered data of a form reactively.
+ * Memoised to minimize re-renders
+ *
  */
 function useFilteredFormData() {
   const {
@@ -1722,12 +2354,12 @@ function useFilteredFormData() {
   }, [conditionChecker, data, initialData]);
 }
 
-/**
- * Evaluate if condition is met reactively based on the conditionChecker and form data.
- *
- * @param {string | undefined} condition
- *
- * @returns {boolean} true if condition is met or no condition or condition checker exists
+/**
+ * Evaluate if condition is met reactively based on the conditionChecker and form data.
+ *
+ * @param {string | undefined} condition
+ *
+ * @returns {boolean} true if condition is met or no condition or condition checker exists
  */
 function useCondition(condition) {
   const conditionChecker = useService('conditionChecker', false);
@@ -1737,13 +2369,13 @@ function useCondition(condition) {
   }, [conditionChecker, condition, filteredData]);
 }
 
-/**
- * Evaluate a string reactively based on the expressionLanguage and form data.
- * If the string is not an expression, it is returned as is.
- * Memoised to minimize re-renders.
- *
- * @param {string} value
- *
+/**
+ * Evaluate a string reactively based on the expressionLanguage and form data.
+ * If the string is not an expression, it is returned as is.
+ * Memoised to minimize re-renders.
+ *
+ * @param {string} value
+ *
  */
 function useExpressionEvaluation(value) {
   const formData = useFilteredFormData();
@@ -1772,16 +2404,16 @@ function useKeyDownAction(targetKey, action, listenerElement = window) {
   });
 }
 
-/**
- * Retrieve readonly value of a form field, given it can be an
- * expression optionally or configured globally.
- *
- * @typedef { import('../../types').FormProperties } FormProperties
- *
- * @param {any} formField
- * @param {FormProperties} properties
- *
- * @returns {boolean}
+/**
+ * Retrieve readonly value of a form field, given it can be an
+ * expression optionally or configured globally.
+ *
+ * @typedef { import('../../types').FormProperties } FormProperties
+ *
+ * @param {any} formField
+ * @param {FormProperties} properties
+ *
+ * @returns {boolean}
  */
 function useReadonly(formField, properties = {}) {
   const expressionLanguage = useService('expressionLanguage');
@@ -1799,16 +2431,16 @@ function useReadonly(formField, properties = {}) {
   return readonly || false;
 }
 
-/**
- * Template a string reactively based on form data. If the string is not a template, it is returned as is.
- * Memoised to minimize re-renders
- *
- * @param {string} value
- * @param {Object} options
- * @param {boolean} [options.debug = false]
- * @param {boolean} [options.strict = false]
- * @param {Function} [options.buildDebugString]
- *
+/**
+ * Template a string reactively based on form data. If the string is not a template, it is returned as is.
+ * Memoised to minimize re-renders
+ *
+ * @param {string} value
+ * @param {Object} options
+ * @param {boolean} [options.debug = false]
+ * @param {boolean} [options.strict = false]
+ * @param {Function} [options.buildDebugString]
+ *
  */
 function useTemplateEvaluation(value, options) {
   const filteredData = useFilteredFormData();
@@ -1821,17 +2453,17 @@ function useTemplateEvaluation(value, options) {
   }, [filteredData, templating, value, options]);
 }
 
-/**
- * Template a string reactively based on form data. If the string is not a template, it is returned as is.
- * If the string contains multiple lines, only the first line is returned.
- * Memoised to minimize re-renders
- *
- * @param {string} value
- * @param {Object} [options]
- * @param {boolean} [options.debug = false]
- * @param {boolean} [options.strict = false]
- * @param {Function} [options.buildDebugString]
- *
+/**
+ * Template a string reactively based on form data. If the string is not a template, it is returned as is.
+ * If the string contains multiple lines, only the first line is returned.
+ * Memoised to minimize re-renders
+ *
+ * @param {string} value
+ * @param {Object} [options]
+ * @param {boolean} [options.debug = false]
+ * @param {boolean} [options.strict = false]
+ * @param {Function} [options.buildDebugString]
+ *
  */
 function useSingleLineTemplateEvaluation(value, options = {}) {
   const evaluatedTemplate = useTemplateEvaluation(value, options);
@@ -1898,11 +2530,12 @@ function Label(props) {
   });
 }
 
-const type$a = 'checkbox';
+const type$b = 'checkbox';
 function Checkbox(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value = false
@@ -1929,7 +2562,7 @@ function Checkbox(props) {
   } = useContext(FormContext$1);
   const errorMessageId = errors.length === 0 ? undefined : `${prefixId(id, formId)}-error-message`;
   return jsxs("div", {
-    class: classNames(formFieldClasses(type$a, {
+    class: classNames(formFieldClasses(type$b, {
       errors,
       disabled,
       readonly
@@ -1948,6 +2581,7 @@ function Checkbox(props) {
         id: prefixId(id, formId),
         type: "checkbox",
         onChange: onChange,
+        onBlur: onBlur,
         "aria-describedby": errorMessageId
       })
     }), jsx(Description, {
@@ -1959,7 +2593,7 @@ function Checkbox(props) {
   });
 }
 Checkbox.config = {
-  type: type$a,
+  type: type$b,
   keyed: true,
   label: 'Checkbox',
   group: 'selection',
@@ -2018,8 +2652,8 @@ function _isValueSomething(value) {
   return value || value === 0 || value === false;
 }
 
-/**
- * @enum { String }
+/**
+ * @enum { String }
  */
 const LOAD_STATES = {
   LOADING: 'loading',
@@ -2027,20 +2661,21 @@ const LOAD_STATES = {
   ERROR: 'error'
 };
 
-/**
- * @typedef {Object} ValuesGetter
- * @property {Object[]} values - The values data
- * @property {(LOAD_STATES)} state - The values data's loading state, to use for conditional rendering
+/**
+ * @typedef {Object} ValuesGetter
+ * @property {Object[]} values - The values data
+ * @property {(LOAD_STATES)} state - The values data's loading state, to use for conditional rendering
  */
 
-/**
- * A hook to load values for single and multiselect components.
- *
- * @param {Object} field - The form field to handle values for
- * @return {ValuesGetter} valuesGetter - A values getter object providing loading state and values
+/**
+ * A hook to load values for single and multiselect components.
+ *
+ * @param {Object} field - The form field to handle values for
+ * @return {ValuesGetter} valuesGetter - A values getter object providing loading state and values
  */
 function useValuesAsync (field) {
   const {
+    valuesExpression,
     valuesKey,
     values: staticValues
   } = field;
@@ -2050,6 +2685,11 @@ function useValuesAsync (field) {
     state: LOAD_STATES.LOADING
   });
   const initialData = useService('form')._getState().initialData;
+  const evaluatedValues = useMemo(() => {
+    if (valuesExpression) {
+      return useExpressionEvaluation(valuesExpression);
+    }
+  }, [valuesExpression]);
   useEffect(() => {
     let values = [];
 
@@ -2059,11 +2699,14 @@ function useValuesAsync (field) {
       if (keyedValues && Array.isArray(keyedValues)) {
         values = keyedValues;
       }
-    }
 
-    // static values
-    else if (staticValues !== undefined) {
+      // static values
+    } else if (staticValues !== undefined) {
       values = Array.isArray(staticValues) ? staticValues : [];
+
+      // expression
+    } else if (evaluatedValues && Array.isArray(evaluatedValues)) {
+      values = evaluatedValues;
     } else {
       setValuesGetter(buildErrorState('No values source defined in the form definition'));
       return;
@@ -2293,11 +2936,12 @@ function sanitizeMultiSelectValue(options) {
   }
 }
 
-const type$9 = 'checklist';
+const type$a = 'checklist';
 function Checklist(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value = []
@@ -2308,6 +2952,7 @@ function Checklist(props) {
     label,
     validate = {}
   } = field;
+  const outerDivRef = useRef();
   const {
     required
   } = validate;
@@ -2323,6 +2968,12 @@ function Checklist(props) {
       value: newValue
     });
   };
+  const onCheckboxBlur = e => {
+    if (outerDivRef.current.contains(e.relatedTarget)) {
+      return;
+    }
+    onBlur();
+  };
   const {
     state: loadState,
     values: options
@@ -2332,11 +2983,12 @@ function Checklist(props) {
   } = useContext(FormContext$1);
   const errorMessageId = errors.length === 0 ? undefined : `${prefixId(id, formId)}-error-message`;
   return jsxs("div", {
-    class: classNames(formFieldClasses(type$9, {
+    class: classNames(formFieldClasses(type$a, {
       errors,
       disabled,
       readonly
     })),
+    ref: outerDivRef,
     children: [jsx(Label, {
       label: label,
       required: required
@@ -2356,6 +3008,7 @@ function Checklist(props) {
           id: prefixId(`${id}-${index}`, formId),
           type: "checkbox",
           onClick: () => toggleCheckbox(v.value),
+          onBlur: onCheckboxBlur,
           "aria-describedby": errorMessageId
         })
       }, `${id}-${index}`);
@@ -2368,7 +3021,7 @@ function Checklist(props) {
   });
 }
 Checklist.config = {
-  type: type$9,
+  type: type$a,
   keyed: true,
   label: 'Checklist',
   group: 'selection',
@@ -2398,8 +3051,10 @@ function FormField(props) {
     onChange
   } = props;
   const formFields = useService('formFields'),
+    viewerCommands = useService('viewerCommands', false),
     form = useService('form');
   const {
+    initialData,
     data,
     errors,
     properties
@@ -2413,12 +3068,23 @@ function FormField(props) {
   if (!FormFieldComponent) {
     throw new Error(`cannot render field <${field.type}>`);
   }
+  const initialValue = useMemo(() => get(initialData, field._path), [initialData, field._path]);
   const value = get(data, field._path);
   const fieldErrors = findErrors(errors, field._path);
   const readonly = useReadonly(field, properties);
 
   // add precedence: global readonly > form field disabled
   const disabled = !properties.readOnly && (properties.disabled || field.disabled || false);
+  const onBlur = useCallback(() => {
+    if (viewerCommands) {
+      viewerCommands.updateFieldValidation(field, value);
+    }
+  }, [viewerCommands, field, value]);
+  useEffect(() => {
+    if (viewerCommands && initialValue) {
+      viewerCommands.updateFieldValidation(field, initialValue);
+    }
+  }, [viewerCommands, field, initialValue]);
   const hidden = useCondition(field.conditional && field.conditional.hide || null);
   if (hidden) {
     return jsx(Empty, {});
@@ -2434,6 +3100,7 @@ function FormField(props) {
         disabled: disabled,
         errors: fieldErrors,
         onChange: disabled || readonly ? noop$1 : onChange,
+        onBlur: disabled || readonly ? noop$1 : onBlur,
         readonly: readonly,
         value: value
       })
@@ -2496,22 +3163,23 @@ Default.config = {
   })
 };
 
-function _extends$j() { _extends$j = 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$j.apply(this, arguments); }
-var CalendarIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$j({
-  width: "14",
-  height: "15",
-  viewBox: "0 0 28 30",
-  fill: "none",
-  xmlns: "http://www.w3.org/2000/svg"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  clipRule: "evenodd",
-  fill: "currentColor",
-  d: "M19 2H9V0H7v2H2a2 2 0 00-2 2v24a2 2 0 002 2h24a2 2 0 002-2V4a2 2 0 00-2-2h-5V0h-2v2zM7 7V4H2v5h24V4h-5v3h-2V4H9v3H7zm-5 4v17h24V11H2z"
-})));
+var _path$h;
+function _extends$k() { _extends$k = 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$k.apply(this, arguments); }
+var SvgCalendar = function SvgCalendar(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$k({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 14,
+    height: 15,
+    fill: "none",
+    viewBox: "0 0 28 30"
+  }, props), _path$h || (_path$h = /*#__PURE__*/React.createElement("path", {
+    fill: "currentColor",
+    fillRule: "evenodd",
+    d: "M19 2H9V0H7v2H2a2 2 0 0 0-2 2v24a2 2 0 0 0 2 2h24a2 2 0 0 0 2-2V4a2 2 0 0 0-2-2h-5V0h-2v2ZM7 7V4H2v5h24V4h-5v3h-2V4H9v3H7Zm-5 4v17h24V11H2Z",
+    clipRule: "evenodd"
+  })));
+};
+var CalendarIcon = SvgCalendar;
 
 function InputAdorner(props) {
   const {
@@ -2556,6 +3224,7 @@ function Datepicker(props) {
     id,
     label,
     collapseLabelOnEmpty,
+    onDateTimeBlur,
     formId,
     required,
     disabled,
@@ -2650,7 +3319,8 @@ function Datepicker(props) {
     if (!isInputDirty || e.relatedTarget && e.relatedTarget.classList.contains('flatpickr-day')) return;
     dateInputRef.current.dispatchEvent(ENTER_KEYDOWN_EVENT);
     setIsInputDirty(false);
-  }, [isInputDirty]);
+    onDateTimeBlur(e);
+  }, [isInputDirty, onDateTimeBlur]);
   const fullId = `${prefixId(id, formId)}--date`;
   return jsxs("div", {
     class: "fjs-datetime-subsection",
@@ -2692,25 +3362,26 @@ function Datepicker(props) {
   });
 }
 
-function _extends$i() { _extends$i = 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$i.apply(this, arguments); }
-var ClockIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$i({
-  width: "16",
-  height: "16",
-  viewBox: "0 0 28 29",
-  fill: "none",
-  xmlns: "http://www.w3.org/2000/svg"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fill: "currentColor",
-  d: "M13 14.41L18.59 20 20 18.59l-5-5.01V5h-2v9.41z"
-}), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  clipRule: "evenodd",
-  fill: "currentColor",
-  d: "M6.222 25.64A14 14 0 1021.778 2.36 14 14 0 006.222 25.64zM7.333 4.023a12 12 0 1113.334 19.955A12 12 0 017.333 4.022z"
-})));
+var _path$g, _path2$4;
+function _extends$j() { _extends$j = 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$j.apply(this, arguments); }
+var SvgClock = function SvgClock(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$j({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 16,
+    height: 16,
+    fill: "none",
+    viewBox: "0 0 28 29"
+  }, props), _path$g || (_path$g = /*#__PURE__*/React.createElement("path", {
+    fill: "currentColor",
+    d: "M13 14.41 18.59 20 20 18.59l-5-5.01V5h-2v9.41Z"
+  })), _path2$4 || (_path2$4 = /*#__PURE__*/React.createElement("path", {
+    fill: "currentColor",
+    fillRule: "evenodd",
+    d: "M6.222 25.64A14 14 0 1 0 21.778 2.36 14 14 0 0 0 6.222 25.64ZM7.333 4.023a12 12 0 1 1 13.334 19.955A12 12 0 0 1 7.333 4.022Z",
+    clipRule: "evenodd"
+  })));
+};
+var ClockIcon = SvgClock;
 
 const DEFAULT_LABEL_GETTER = value => value;
 const NOOP = () => {};
@@ -2812,6 +3483,7 @@ function Timepicker(props) {
     id,
     label,
     collapseLabelOnEmpty,
+    onDateTimeBlur,
     formId,
     required,
     disabled,
@@ -2911,6 +3583,7 @@ function Timepicker(props) {
   const onInputBlur = e => {
     setDropdownIsOpen(false);
     propagateRawToMinute();
+    onDateTimeBlur(e);
   };
   const onDropdownValueSelected = value => {
     setDropdownIsOpen(false);
@@ -2966,11 +3639,12 @@ function Timepicker(props) {
   });
 }
 
-const type$8 = 'datetime';
+const type$9 = 'datetime';
 function Datetime(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     onChange,
     readonly,
@@ -2994,6 +3668,7 @@ function Datetime(props) {
   const {
     formId
   } = useContext(FormContext$1);
+  const dateTimeGroupRef = useRef();
   const getNullDateTime = () => ({
     date: new Date(Date.parse(null)),
     time: null
@@ -3004,6 +3679,12 @@ function Datetime(props) {
   const isValidTime = time => !isNaN(parseInt(time));
   const useDatePicker = useMemo(() => subtype === DATETIME_SUBTYPES.DATE || subtype === DATETIME_SUBTYPES.DATETIME, [subtype]);
   const useTimePicker = useMemo(() => subtype === DATETIME_SUBTYPES.TIME || subtype === DATETIME_SUBTYPES.DATETIME, [subtype]);
+  const onDateTimeBlur = useCallback(e => {
+    if (e.relatedTarget && dateTimeGroupRef.current.contains(e.relatedTarget)) {
+      return;
+    }
+    onBlur();
+  }, [onBlur]);
   useEffect(() => {
     let {
       date,
@@ -3095,6 +3776,7 @@ function Datetime(props) {
     id,
     label: dateLabel,
     collapseLabelOnEmpty: !timeLabel,
+    onDateTimeBlur,
     formId,
     required,
     disabled,
@@ -3108,6 +3790,7 @@ function Datetime(props) {
     id,
     label: timeLabel,
     collapseLabelOnEmpty: !dateLabel,
+    onDateTimeBlur,
     formId,
     required,
     disabled,
@@ -3119,13 +3802,14 @@ function Datetime(props) {
     'aria-describedby': errorMessageId
   };
   return jsxs("div", {
-    class: formFieldClasses(type$8, {
+    class: formFieldClasses(type$9, {
       errors: allErrors,
       disabled,
       readonly
     }),
     children: [jsxs("div", {
       class: classNames('fjs-vertical-group'),
+      ref: dateTimeGroupRef,
       children: [useDatePicker && jsx(Datepicker, {
         ...datePickerProps
       }), useTimePicker && useDatePicker && jsx("div", {
@@ -3142,7 +3826,7 @@ function Datetime(props) {
   });
 }
 Datetime.config = {
-  type: type$8,
+  type: type$9,
   keyed: true,
   label: 'Date time',
   group: 'basic-input',
@@ -3159,10 +3843,10 @@ Datetime.config = {
   }
 };
 
-/**
- * This file must not be changed or exchanged.
- *
- * @see http://bpmn.io/license for more information.
+/**
+ * This file must not be changed or exchanged.
+ *
+ * @see http://bpmn.io/license for more information.
  */
 function Logo() {
   return jsxs("svg", {
@@ -3294,11 +3978,11 @@ const ATTR_WHITESPACE_PATTERN = /[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u
 
 const FORM_ELEMENT = document.createElement('form');
 
-/**
- * Sanitize a HTML string and return the cleaned, safe version.
- *
- * @param {string} html
- * @return {string}
+/**
+ * Sanitize a HTML string and return the cleaned, safe version.
+ *
+ * @param {string} html
+ * @return {string}
  */
 
 // see https://github.com/developit/snarkdown/issues/70
@@ -3316,29 +4000,29 @@ function sanitizeHTML(html) {
   }
 }
 
-/**
- * Sanitizes an image source to ensure we only allow for data URI and links
- * that start with http(s).
- *
- * Note: Most browsers anyway do not support script execution in <img> elements.
- *
- * @param {string} src
- * @returns {string}
+/**
+ * Sanitizes an image source to ensure we only allow for data URI and links
+ * that start with http(s).
+ *
+ * Note: Most browsers anyway do not support script execution in <img> elements.
+ *
+ * @param {string} src
+ * @returns {string}
  */
 function sanitizeImageSource(src) {
   const valid = ALLOWED_IMAGE_SRC_PATTERN.test(src);
   return valid ? src : '';
 }
 
-/**
- * Recursively sanitize a HTML node, potentially
- * removing it, its children or attributes.
- *
- * Inspired by https://github.com/developit/snarkdown/issues/70
- * and https://github.com/cure53/DOMPurify. Simplified
- * for our use-case.
- *
- * @param {Element} node
+/**
+ * Recursively sanitize a HTML node, potentially
+ * removing it, its children or attributes.
+ *
+ * Inspired by https://github.com/developit/snarkdown/issues/70
+ * and https://github.com/cure53/DOMPurify. Simplified
+ * for our use-case.
+ *
+ * @param {Element} node
  */
 function sanitizeNode(node) {
   // allow text nodes
@@ -3382,13 +4066,13 @@ function sanitizeNode(node) {
   }
 }
 
-/**
- * Validates attributes for validity.
- *
- * @param {string} lcTag
- * @param {string} lcName
- * @param {string} value
- * @return {boolean}
+/**
+ * Validates attributes for validity.
+ *
+ * @param {string} lcTag
+ * @param {string} lcName
+ * @param {string} value
+ * @return {boolean}
  */
 function isValidAttribute(lcTag, lcName, value) {
   // disallow most attributes based on whitelist
@@ -3411,37 +4095,48 @@ function isValidAttribute(lcTag, lcName, value) {
   return true;
 }
 
-function _extends$h() { _extends$h = 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$h.apply(this, arguments); }
-var ImagePlaceholder = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$h({
-  width: "64",
-  height: "64",
-  viewBox: "0 0 1280 1280",
-  xmlns: "http://www.w3.org/2000/svg",
-  fillRule: "evenodd",
-  clipRule: "evenodd",
-  strokeLinejoin: "round",
-  strokeMiterlimit: "2"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fill: "#e5e9ed",
-  d: "M0 0h1280v1280H0z"
-}), /*#__PURE__*/React.createElement("path", {
-  d: "M910 410H370v470h540V410zm-57.333 57.333v355.334H427.333V467.333h425.334z",
-  fill: "#cad3db"
-}), /*#__PURE__*/React.createElement("path", {
-  d: "M810 770H480v-60l100-170 130 170 100-65v125z",
-  fill: "#cad3db"
-}), /*#__PURE__*/React.createElement("circle", {
-  cx: "750",
-  cy: "550",
-  r: "50",
-  fill: "#cad3db",
-  transform: "translate(10 10)"
-})));
-
-const type$7 = 'image';
+function _extends$i() { _extends$i = 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$i.apply(this, arguments); }
+var SvgImagePlaceholder = function SvgImagePlaceholder(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$i({
+    xmlns: "http://www.w3.org/2000/svg",
+    xmlSpace: "preserve",
+    width: 64,
+    height: 64,
+    style: {
+      fillRule: "evenodd",
+      clipRule: "evenodd",
+      strokeLinejoin: "round",
+      strokeMiterlimit: 2
+    },
+    viewBox: "0 0 1280 1280"
+  }, props), /*#__PURE__*/React.createElement("path", {
+    d: "M0 0h1280v1280H0z",
+    style: {
+      fill: "#e5e9ed"
+    }
+  }), /*#__PURE__*/React.createElement("path", {
+    d: "M910 410H370v470h540V410Zm-57.333 57.333v355.334H427.333V467.333h425.334Z",
+    style: {
+      fill: "#cad3db"
+    }
+  }), /*#__PURE__*/React.createElement("path", {
+    d: "M810 770H480v-60l100-170 130 170 100-65v125Z",
+    style: {
+      fill: "#cad3db"
+    }
+  }), /*#__PURE__*/React.createElement("circle", {
+    cx: 750,
+    cy: 550,
+    r: 50,
+    style: {
+      fill: "#cad3db"
+    },
+    transform: "translate(10 10)"
+  }));
+};
+var ImagePlaceholder = SvgImagePlaceholder;
+
+const type$8 = 'image';
 function Image(props) {
   const {
     field
@@ -3451,14 +4146,18 @@ function Image(props) {
     id,
     source
   } = field;
-  const evaluatedImageSource = useExpressionEvaluation(source);
+  const evaluatedImageSource = useSingleLineTemplateEvaluation(source, {
+    debug: true
+  });
   const safeSource = useMemo(() => sanitizeImageSource(evaluatedImageSource), [evaluatedImageSource]);
-  const altText = useExpressionEvaluation(alt);
+  const altText = useSingleLineTemplateEvaluation(alt, {
+    debug: true
+  });
   const {
     formId
   } = useContext(FormContext$1);
   return jsx("div", {
-    class: formFieldClasses(type$7),
+    class: formFieldClasses(type$8),
     children: jsxs("div", {
       class: "fjs-image-container",
       children: [safeSource && jsx("img", {
@@ -3476,7 +4175,7 @@ function Image(props) {
   });
 }
 Image.config = {
-  type: type$7,
+  type: type$8,
   keyed: false,
   label: 'Image view',
   group: 'presentation',
@@ -3485,45 +4184,66 @@ Image.config = {
   })
 };
 
+function TemplatedInputAdorner(props) {
+  const {
+    pre,
+    post
+  } = props;
+  const evaluatedPre = useSingleLineTemplateEvaluation(pre, {
+    debug: true
+  });
+  const evaluatedPost = useSingleLineTemplateEvaluation(post, {
+    debug: true
+  });
+  return jsx(InputAdorner, {
+    ...props,
+    pre: evaluatedPre,
+    post: evaluatedPost
+  });
+}
+
+var _path$f;
+function _extends$h() { _extends$h = 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$h.apply(this, arguments); }
+var SvgAngelDown = function SvgAngelDown(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$h({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 8,
+    height: 8
+  }, props), _path$f || (_path$f = /*#__PURE__*/React.createElement("path", {
+    fill: "currentColor",
+    fillRule: "evenodd",
+    stroke: "currentColor",
+    strokeWidth: 0.5,
+    d: "M7.75 1.336 4 6.125.258 1.335 0 1.54l4 5.125L8 1.54Zm0 0",
+    clipRule: "evenodd"
+  })));
+};
+var AngelDownIcon = SvgAngelDown;
+
+var _path$e;
 function _extends$g() { _extends$g = 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$g.apply(this, arguments); }
-var AngelDownIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$g({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "8",
-  height: "8"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  clipRule: "evenodd",
-  fill: "currentColor",
-  stroke: "currentColor",
-  strokeWidth: ".5",
-  d: "M7.75 1.336L4 6.125.258 1.335 0 1.54l4 5.125L8 1.54zm0 0"
-})));
+var SvgAngelUp = function SvgAngelUp(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$g({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 8,
+    height: 8
+  }, props), _path$e || (_path$e = /*#__PURE__*/React.createElement("path", {
+    fill: "currentColor",
+    fillRule: "evenodd",
+    stroke: "currentColor",
+    strokeWidth: 0.5,
+    d: "M7.75 6.664 4 1.875.258 6.665 0 6.46l4-5.125L8 6.46Zm0 0",
+    clipRule: "evenodd"
+  })));
+};
+var AngelUpIcon = SvgAngelUp;
 
-function _extends$f() { _extends$f = 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$f.apply(this, arguments); }
-var AngelUpIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$f({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "8",
-  height: "8"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  clipRule: "evenodd",
-  fill: "currentColor",
-  stroke: "currentColor",
-  strokeWidth: ".5",
-  d: "M7.75 6.664L4 1.875.258 6.665 0 6.46l4-5.125L8 6.46zm0 0"
-})));
-
-const type$6 = 'number';
+const type$7 = 'number';
 function Numberfield(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     value,
     readonly,
@@ -3656,7 +4376,7 @@ function Numberfield(props) {
   } = useContext(FormContext$1);
   const errorMessageId = errors.length === 0 ? undefined : `${prefixId(id, formId)}-error-message`;
   return jsxs("div", {
-    class: formFieldClasses(type$6, {
+    class: formFieldClasses(type$7, {
       errors,
       disabled,
       readonly
@@ -3665,7 +4385,7 @@ function Numberfield(props) {
       id: prefixId(id, formId),
       label: label,
       required: required
-    }), jsx(InputAdorner, {
+    }), jsx(TemplatedInputAdorner, {
       disabled: disabled,
       readonly: readonly,
       pre: prefixAdorner,
@@ -3684,7 +4404,8 @@ function Numberfield(props) {
           readOnly: readonly,
           id: prefixId(id, formId),
           onKeyDown: onKeyDown,
-          onKeyPress: onKeyPress
+          onKeyPress: onKeyPress,
+          onBlur: onBlur
 
           // @ts-ignore
           ,
@@ -3727,7 +4448,7 @@ function Numberfield(props) {
   });
 }
 Numberfield.config = {
-  type: type$6,
+  type: type$7,
   keyed: true,
   label: 'Number',
   group: 'basic-input',
@@ -3750,11 +4471,12 @@ Numberfield.config = {
   })
 };
 
-const type$5 = 'radio';
+const type$6 = 'radio';
 function Radio(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value
@@ -3765,6 +4487,7 @@ function Radio(props) {
     label,
     validate = {}
   } = field;
+  const outerDivRef = useRef();
   const {
     required
   } = validate;
@@ -3774,6 +4497,12 @@ function Radio(props) {
       value: v
     });
   };
+  const onRadioBlur = e => {
+    if (outerDivRef.current.contains(e.relatedTarget)) {
+      return;
+    }
+    onBlur();
+  };
   const {
     state: loadState,
     values: options
@@ -3783,11 +4512,12 @@ function Radio(props) {
   } = useContext(FormContext$1);
   const errorMessageId = errors.length === 0 ? undefined : `${prefixId(id, formId)}-error-message`;
   return jsxs("div", {
-    class: formFieldClasses(type$5, {
+    class: formFieldClasses(type$6, {
       errors,
       disabled,
       readonly
     }),
+    ref: outerDivRef,
     children: [jsx(Label, {
       label: label,
       required: required
@@ -3807,6 +4537,7 @@ function Radio(props) {
           id: prefixId(`${id}-${index}`, formId),
           type: "radio",
           onClick: () => onChange(option.value),
+          onBlur: onRadioBlur,
           "aria-describedby": errorMessageId
         })
       }, `${id}-${index}`);
@@ -3819,7 +4550,7 @@ function Radio(props) {
   });
 }
 Radio.config = {
-  type: type$5,
+  type: type$6,
   keyed: true,
   label: 'Radio',
   group: 'selection',
@@ -3842,28 +4573,30 @@ Radio.config = {
   }
 };
 
-function _extends$e() { _extends$e = 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$e.apply(this, arguments); }
-var XMarkIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$e({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "8",
-  height: "8"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  clipRule: "evenodd",
-  fill: "currentColor",
-  stroke: "currentColor",
-  strokeWidth: ".5",
-  d: "M4 3.766L7.43.336l.234.234L4.234 4l3.43 3.43-.234.234L4 4.234.57 7.664.336 7.43 3.766 4 .336.57.57.336zm0 0"
-})));
+var _path$d;
+function _extends$f() { _extends$f = 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$f.apply(this, arguments); }
+var SvgXMark = function SvgXMark(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$f({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 8,
+    height: 8
+  }, props), _path$d || (_path$d = /*#__PURE__*/React.createElement("path", {
+    fill: "currentColor",
+    fillRule: "evenodd",
+    stroke: "currentColor",
+    strokeWidth: 0.5,
+    d: "M4 3.766 7.43.336l.234.234L4.234 4l3.43 3.43-.234.234L4 4.234.57 7.664.336 7.43 3.766 4 .336.57.57.336Zm0 0",
+    clipRule: "evenodd"
+  })));
+};
+var XMarkIcon = SvgXMark;
 
 function SearchableSelect(props) {
   const {
     id,
     disabled,
     errors,
+    onBlur,
     field,
     readonly,
     value
@@ -3983,6 +4716,7 @@ function SearchableSelect(props) {
         onBlur: () => {
           setIsDropdownExpanded(false);
           setFilter(valueLabel);
+          onBlur();
         },
         "aria-describedby": props['aria-describedby']
       }), displayState.displayCross && jsxs("span", {
@@ -4017,6 +4751,7 @@ function SimpleSelect(props) {
     id,
     disabled,
     errors,
+    onBlur,
     field,
     readonly,
     value
@@ -4071,7 +4806,10 @@ function SimpleSelect(props) {
         'hasErrors': errors.length
       }),
       onFocus: () => setIsDropdownExpanded(true),
-      onBlur: () => setIsDropdownExpanded(false),
+      onBlur: () => {
+        setIsDropdownExpanded(false);
+        onBlur();
+      },
       onMouseDown: onMouseDown,
       children: [jsx("div", {
         class: classNames('fjs-select-display', {
@@ -4113,11 +4851,12 @@ function SimpleSelect(props) {
   });
 }
 
-const type$4 = 'select';
+const type$5 = 'select';
 function Select(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     onChange,
     readonly,
@@ -4141,14 +4880,15 @@ function Select(props) {
     id,
     disabled,
     errors,
+    onBlur,
     field,
     value,
     onChange,
     readonly,
     'aria-describedby': errorMessageId
-  }), [disabled, errors, field, id, value, onChange, readonly, errorMessageId]);
+  }), [disabled, errors, field, id, value, onChange, onBlur, readonly, errorMessageId]);
   return jsxs("div", {
-    class: formFieldClasses(type$4, {
+    class: formFieldClasses(type$5, {
       errors,
       disabled,
       readonly
@@ -4176,7 +4916,7 @@ function Select(props) {
   });
 }
 Select.config = {
-  type: type$4,
+  type: type$5,
   keyed: true,
   label: 'Select',
   group: 'selection',
@@ -4199,11 +4939,38 @@ Select.config = {
   }
 };
 
+const type$4 = 'spacer';
+function Spacer(props) {
+  const {
+    field
+  } = props;
+  const {
+    height = 60
+  } = field;
+  return jsx("div", {
+    class: formFieldClasses(type$4),
+    style: {
+      height: height
+    }
+  });
+}
+Spacer.config = {
+  type: type$4,
+  keyed: false,
+  label: 'Spacer',
+  group: 'presentation',
+  create: (options = {}) => ({
+    height: 60,
+    ...options
+  })
+};
+
 const type$3 = 'taglist';
 function Taglist(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value: values = []
@@ -4296,9 +5063,10 @@ function Taglist(props) {
         break;
     }
   };
-  const onBlur = () => {
+  const onComponentBlur = () => {
     setIsDropdownExpanded(false);
     setFilter('');
+    onBlur();
   };
   const onTagRemoveClick = (event, value) => {
     const {
@@ -4369,9 +5137,7 @@ function Taglist(props) {
         onKeyDown: onInputKeyDown,
         onMouseDown: () => setIsEscapeClose(false),
         onFocus: () => !readonly && setIsDropdownExpanded(true),
-        onBlur: () => {
-          !readonly && onBlur();
-        },
+        onBlur: () => !readonly && onComponentBlur(),
         "aria-describedby": errorMessageId
       })]
     }), jsx("div", {
@@ -4504,6 +5270,7 @@ function Textfield(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value = ''
@@ -4544,7 +5311,7 @@ function Textfield(props) {
       id: prefixId(id, formId),
       label: label,
       required: required
-    }), jsx(InputAdorner, {
+    }), jsx(TemplatedInputAdorner, {
       disabled: disabled,
       readonly: readonly,
       pre: prefixAdorner,
@@ -4555,6 +5322,7 @@ function Textfield(props) {
         readOnly: readonly,
         id: prefixId(id, formId),
         onInput: onChange,
+        onBlur: onBlur,
         type: "text",
         value: value,
         "aria-describedby": errorMessageId
@@ -4596,6 +5364,7 @@ function Textarea(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value = ''
@@ -4618,22 +5387,12 @@ function Textarea(props) {
       value: target.value
     });
   };
-  const autoSizeTextarea = useCallback(textarea => {
-    // Ensures the textarea shrinks back, and improves resizing behavior consistency
-    textarea.style.height = '0px';
-    const computed = window.getComputedStyle(textarea);
-    const calculatedHeight = parseInt(computed.getPropertyValue('border-top-width')) + parseInt(computed.getPropertyValue('padding-top')) + textarea.scrollHeight + parseInt(computed.getPropertyValue('padding-bottom')) + parseInt(computed.getPropertyValue('border-bottom-width'));
-    const minHeight = 75;
-    const maxHeight = 350;
-    const displayHeight = Math.max(Math.min(calculatedHeight, maxHeight), minHeight);
-    textarea.style.height = `${displayHeight}px`;
-
-    // Overflow is hidden by default to hide scrollbar flickering
-    textarea.style.overflow = calculatedHeight > maxHeight ? 'visible' : 'hidden';
-  }, []);
+  useLayoutEffect(() => {
+    autoSizeTextarea(textareaRef.current);
+  }, [value]);
   useEffect(() => {
     autoSizeTextarea(textareaRef.current);
-  }, [autoSizeTextarea, value]);
+  }, []);
   const {
     formId
   } = useContext(FormContext$1);
@@ -4654,6 +5413,7 @@ function Textarea(props) {
       readonly: readonly,
       id: prefixId(id, formId),
       onInput: onInput,
+      onBlur: onBlur,
       value: value,
       ref: textareaRef,
       "aria-describedby": errorMessageId
@@ -4678,246 +5438,301 @@ Textarea.config = {
     ...options
   })
 };
+const autoSizeTextarea = textarea => {
+  // Ensures the textarea shrinks back, and improves resizing behavior consistency
+  textarea.style.height = '0px';
+  const computed = window.getComputedStyle(textarea);
+  const heightFromLines = () => {
+    const lineHeight = parseInt(computed.getPropertyValue('line-height').replace('px', '')) || 0;
+    const lines = textarea.value ? textarea.value.toString().split('\n').length : 0;
+    return lines * lineHeight;
+  };
+  const calculatedHeight = parseInt(computed.getPropertyValue('border-top-width')) + parseInt(computed.getPropertyValue('padding-top')) + (textarea.scrollHeight || heightFromLines()) + parseInt(computed.getPropertyValue('padding-bottom')) + parseInt(computed.getPropertyValue('border-bottom-width'));
+  const minHeight = 75;
+  const maxHeight = 350;
+  const displayHeight = Math.max(Math.min(calculatedHeight || 0, maxHeight), minHeight);
+  textarea.style.height = `${displayHeight}px`;
+
+  // Overflow is hidden by default to hide scrollbar flickering
+  textarea.style.overflow = calculatedHeight > maxHeight ? 'visible' : 'hidden';
+};
 
+var _path$c;
+function _extends$e() { _extends$e = 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$e.apply(this, arguments); }
+var SvgButton = function SvgButton(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$e({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path$c || (_path$c = /*#__PURE__*/React.createElement("path", {
+    fillRule: "evenodd",
+    d: "M45 17a3 3 0 0 1 3 3v14a3 3 0 0 1-3 3H9a3 3 0 0 1-3-3V20a3 3 0 0 1 3-3h36zm-9 8.889H18v2.222h18v-2.222z"
+  })));
+};
+var ButtonIcon = SvgButton;
+
+var _path$b;
 function _extends$d() { _extends$d = 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$d.apply(this, arguments); }
-var ButtonIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$d({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  d: "M45 17a3 3 0 013 3v14a3 3 0 01-3 3H9a3 3 0 01-3-3V20a3 3 0 013-3h36zm-9 8.889H18v2.222h18v-2.222z"
-})));
+var SvgCheckbox = function SvgCheckbox(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$d({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path$b || (_path$b = /*#__PURE__*/React.createElement("path", {
+    d: "M34 18H20a2 2 0 0 0-2 2v14a2 2 0 0 0 2 2h14a2 2 0 0 0 2-2V20a2 2 0 0 0-2-2zm-9 14-5-5 1.41-1.41L25 29.17l7.59-7.59L34 23l-9 9z"
+  })));
+};
+var CheckboxIcon = SvgCheckbox;
 
+var _g, _use, _use2, _use3, _defs;
 function _extends$c() { _extends$c = 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$c.apply(this, arguments); }
-var CheckboxIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$c({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("path", {
-  d: "M34 18H20a2 2 0 00-2 2v14a2 2 0 002 2h14a2 2 0 002-2V20a2 2 0 00-2-2zm-9 14l-5-5 1.41-1.41L25 29.17l7.59-7.59L34 23l-9 9z"
-})));
+var SvgChecklist = function SvgChecklist(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$c({
+    xmlns: "http://www.w3.org/2000/svg",
+    xmlnsXlink: "http://www.w3.org/1999/xlink",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _g || (_g = /*#__PURE__*/React.createElement("g", {
+    fillRule: "evenodd"
+  }, /*#__PURE__*/React.createElement("use", {
+    xlinkHref: "#Checklist_svg__a"
+  }), /*#__PURE__*/React.createElement("use", {
+    xlinkHref: "#Checklist_svg__a",
+    y: 24
+  }), /*#__PURE__*/React.createElement("use", {
+    xlinkHref: "#Checklist_svg__a",
+    y: 12
+  }))), _use || (_use = /*#__PURE__*/React.createElement("use", {
+    xlinkHref: "#Checklist_svg__b"
+  })), _use2 || (_use2 = /*#__PURE__*/React.createElement("use", {
+    xlinkHref: "#Checklist_svg__b",
+    y: 12
+  })), _use3 || (_use3 = /*#__PURE__*/React.createElement("use", {
+    xlinkHref: "#Checklist_svg__b",
+    y: 24
+  })), _defs || (_defs = /*#__PURE__*/React.createElement("defs", null, /*#__PURE__*/React.createElement("path", {
+    id: "Checklist_svg__a",
+    d: "M18 12h-6v6h6v-6zm-6-2a2 2 0 0 0-2 2v6a2 2 0 0 0 2 2h6a2 2 0 0 0 2-2v-6a2 2 0 0 0-2-2h-6z"
+  }), /*#__PURE__*/React.createElement("path", {
+    id: "Checklist_svg__b",
+    d: "M23 14.5a1 1 0 0 1 1-1h19a1 1 0 0 1 1 1v1a1 1 0 0 1-1 1H24a1 1 0 0 1-1-1v-1z"
+  }))));
+};
+var ChecklistIcon = SvgChecklist;
 
+var _path$a, _path2$3, _path3;
 function _extends$b() { _extends$b = 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$b.apply(this, arguments); }
-var ChecklistIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$b({
-  xmlns: "http://www.w3.org/2000/svg",
-  xmlnsXlink: "http://www.w3.org/1999/xlink",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("g", {
-  fillRule: "evenodd"
-}, /*#__PURE__*/React.createElement("use", {
-  xlinkHref: "#a"
-}), /*#__PURE__*/React.createElement("use", {
-  xlinkHref: "#a",
-  y: "24"
-}), /*#__PURE__*/React.createElement("use", {
-  xlinkHref: "#a",
-  y: "12"
-})), /*#__PURE__*/React.createElement("use", {
-  xlinkHref: "#b"
-}), /*#__PURE__*/React.createElement("use", {
-  xlinkHref: "#b",
-  y: "12"
-}), /*#__PURE__*/React.createElement("use", {
-  xlinkHref: "#b",
-  y: "24"
-}), /*#__PURE__*/React.createElement("defs", null, /*#__PURE__*/React.createElement("path", {
-  id: "a",
-  d: "M18 12h-6v6h6v-6zm-6-2a2 2 0 00-2 2v6a2 2 0 002 2h6a2 2 0 002-2v-6a2 2 0 00-2-2h-6z"
-}), /*#__PURE__*/React.createElement("path", {
-  id: "b",
-  d: "M23 14.5a1 1 0 011-1h19a1 1 0 011 1v1a1 1 0 01-1 1H24a1 1 0 01-1-1v-1z"
-}))));
+var SvgDatetime = function SvgDatetime(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$b({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path$a || (_path$a = /*#__PURE__*/React.createElement("path", {
+    fillRule: "evenodd",
+    d: "M37.908 13.418h-5.004v-2.354h-1.766v2.354H21.13v-2.354h-1.766v2.354H14.36a2.07 2.07 0 0 0-2.06 2.06v23.549a2.07 2.07 0 0 0 2.06 2.06h6.77v-1.766h-6.358a.707.707 0 0 1-.706-.706V15.89c0-.39.316-.707.706-.707h4.592v2.355h1.766v-2.355h10.008v2.355h1.766v-2.355h4.592a.71.71 0 0 1 .707.707v6.358h1.765v-6.77c0-1.133-.927-2.06-2.06-2.06z"
+  })), _path2$3 || (_path2$3 = /*#__PURE__*/React.createElement("path", {
+    d: "m35.13 37.603 1.237-1.237-3.468-3.475v-5.926h-1.754v6.654l3.984 3.984Z"
+  })), _path3 || (_path3 = /*#__PURE__*/React.createElement("path", {
+    fillRule: "evenodd",
+    d: "M23.08 36.962a9.678 9.678 0 1 0 17.883-7.408 9.678 9.678 0 0 0-17.882 7.408Zm4.54-10.292a7.924 7.924 0 1 1 8.805 13.177A7.924 7.924 0 0 1 27.62 26.67Z"
+  })));
+};
+var DatetimeIcon = SvgDatetime;
 
+var _path$9, _path2$2;
 function _extends$a() { _extends$a = 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$a.apply(this, arguments); }
-var DatetimeIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$a({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  d: "M37.908 13.418h-5.004v-2.354h-1.766v2.354H21.13v-2.354h-1.766v2.354H14.36a2.07 2.07 0 00-2.06 2.06v23.549a2.07 2.07 0 002.06 2.06h6.77v-1.766h-6.358a.707.707 0 01-.706-.706V15.89c0-.39.316-.707.706-.707h4.592v2.355h1.766v-2.355h10.008v2.355h1.766v-2.355h4.592a.71.71 0 01.707.707v6.358h1.765v-6.77c0-1.133-.927-2.06-2.06-2.06z"
-}), /*#__PURE__*/React.createElement("path", {
-  d: "M35.13 37.603l1.237-1.237-3.468-3.475v-5.926h-1.754v6.654l3.984 3.984z"
-}), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  d: "M23.08 36.962a9.678 9.678 0 1017.883-7.408 9.678 9.678 0 00-17.882 7.408zm4.54-10.292a7.924 7.924 0 118.805 13.177A7.924 7.924 0 0127.62 26.67z"
-})));
+var SvgTaglist = function SvgTaglist(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$a({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path$9 || (_path$9 = /*#__PURE__*/React.createElement("path", {
+    fillRule: "evenodd",
+    d: "M45 16a3 3 0 0 1 3 3v16a3 3 0 0 1-3 3H9a3 3 0 0 1-3-3V19a3 3 0 0 1 3-3h36Zm0 2H9a1 1 0 0 0-1 1v16a1 1 0 0 0 1 1h36a1 1 0 0 0 1-1V19a1 1 0 0 0-1-1Z"
+  })), _path2$2 || (_path2$2 = /*#__PURE__*/React.createElement("path", {
+    d: "M11 22a1 1 0 0 1 1-1h19a1 1 0 0 1 1 1v10a1 1 0 0 1-1 1H12a1 1 0 0 1-1-1V22Z"
+  })));
+};
+var TaglistIcon = SvgTaglist;
 
+var _rect, _rect2, _rect3;
 function _extends$9() { _extends$9 = 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$9.apply(this, arguments); }
-var TaglistIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$9({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  d: "M45 16a3 3 0 013 3v16a3 3 0 01-3 3H9a3 3 0 01-3-3V19a3 3 0 013-3h36zm0 2H9a1 1 0 00-1 1v16a1 1 0 001 1h36a1 1 0 001-1V19a1 1 0 00-1-1z"
-}), /*#__PURE__*/React.createElement("path", {
-  d: "M11 22a1 1 0 011-1h19a1 1 0 011 1v10a1 1 0 01-1 1H12a1 1 0 01-1-1V22z"
-})));
+var SvgForm = function SvgForm(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$9({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54
+  }, props), _rect || (_rect = /*#__PURE__*/React.createElement("rect", {
+    width: 24,
+    height: 4,
+    x: 15,
+    y: 17,
+    rx: 1
+  })), _rect2 || (_rect2 = /*#__PURE__*/React.createElement("rect", {
+    width: 24,
+    height: 4,
+    x: 15,
+    y: 25,
+    rx: 1
+  })), _rect3 || (_rect3 = /*#__PURE__*/React.createElement("rect", {
+    width: 13,
+    height: 4,
+    x: 15,
+    y: 33,
+    rx: 1
+  })));
+};
+var FormIcon = SvgForm;
 
+var _path$8;
 function _extends$8() { _extends$8 = 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$8.apply(this, arguments); }
-var FormIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$8({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54"
-}, props), /*#__PURE__*/React.createElement("rect", {
-  width: "24",
-  height: "4",
-  x: "15",
-  y: "17",
-  rx: "1"
-}), /*#__PURE__*/React.createElement("rect", {
-  width: "24",
-  height: "4",
-  x: "15",
-  y: "25",
-  rx: "1"
-}), /*#__PURE__*/React.createElement("rect", {
-  width: "13",
-  height: "4",
-  x: "15",
-  y: "33",
-  rx: "1"
-})));
+var SvgGroup = function SvgGroup(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$8({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54
+  }, props), _path$8 || (_path$8 = /*#__PURE__*/React.createElement("path", {
+    fillRule: "evenodd",
+    d: "M8 33v5a1 1 0 0 0 1 1h4v2H9a3 3 0 0 1-3-3v-5h2Zm18 6v2H15v-2h11Zm13 0v2H28v-2h11Zm9-6v5a3 3 0 0 1-3 3h-4v-2h4a1 1 0 0 0 .993-.883L46 38v-5h2ZM8 22v9H6v-9h2Zm40 0v9h-2v-9h2Zm-35-9v2H9a1 1 0 0 0-.993.883L8 16v4H6v-4a3 3 0 0 1 3-3h4Zm32 0a3 3 0 0 1 3 3v4h-2v-4a1 1 0 0 0-.883-.993L45 15h-4v-2h4Zm-6 0v2H28v-2h11Zm-13 0v2H15v-2h11Z"
+  })));
+};
+var ColumnsIcon = SvgGroup;
 
+var _path$7;
 function _extends$7() { _extends$7 = 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$7.apply(this, arguments); }
-var ColumnsIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$7({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  d: "M8 33v5a1 1 0 001 1h4v2H9a3 3 0 01-3-3v-5h2zm18 6v2H15v-2h11zm13 0v2H28v-2h11zm9-6v5a3 3 0 01-3 3h-4v-2h4a1 1 0 00.993-.883L46 38v-5h2zM8 22v9H6v-9h2zm40 0v9h-2v-9h2zm-35-9v2H9a1 1 0 00-.993.883L8 16v4H6v-4a3 3 0 013-3h4zm32 0a3 3 0 013 3v4h-2v-4a1 1 0 00-.883-.993L45 15h-4v-2h4zm-6 0v2H28v-2h11zm-13 0v2H15v-2h11z"
-})));
+var SvgNumber = function SvgNumber(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$7({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path$7 || (_path$7 = /*#__PURE__*/React.createElement("path", {
+    fillRule: "evenodd",
+    d: "M45 16a3 3 0 0 1 3 3v16a3 3 0 0 1-3 3H9a3 3 0 0 1-3-3V19a3 3 0 0 1 3-3h36zm0 2H9a1 1 0 0 0-1 1v16a1 1 0 0 0 1 1h36a1 1 0 0 0 1-1V19a1 1 0 0 0-1-1zM35 28.444h7l-3.5 4-3.5-4zM35 26h7l-3.5-4-3.5 4z"
+  })));
+};
+var NumberIcon = SvgNumber;
 
+var _path$6;
 function _extends$6() { _extends$6 = 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$6.apply(this, arguments); }
-var NumberIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$6({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  d: "M45 16a3 3 0 013 3v16a3 3 0 01-3 3H9a3 3 0 01-3-3V19a3 3 0 013-3h36zm0 2H9a1 1 0 00-1 1v16a1 1 0 001 1h36a1 1 0 001-1V19a1 1 0 00-1-1zM35 28.444h7l-3.5 4-3.5-4zM35 26h7l-3.5-4-3.5 4z"
-})));
+var SvgRadio = function SvgRadio(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$6({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path$6 || (_path$6 = /*#__PURE__*/React.createElement("path", {
+    d: "M27 22c-2.76 0-5 2.24-5 5s2.24 5 5 5 5-2.24 5-5-2.24-5-5-5zm0-5c-5.52 0-10 4.48-10 10s4.48 10 10 10 10-4.48 10-10-4.48-10-10-10zm0 18a8 8 0 1 1 0-16 8 8 0 1 1 0 16z"
+  })));
+};
+var RadioIcon = SvgRadio;
 
+var _path$5;
 function _extends$5() { _extends$5 = 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$5.apply(this, arguments); }
-var RadioIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$5({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("path", {
-  d: "M27 22c-2.76 0-5 2.24-5 5s2.24 5 5 5 5-2.24 5-5-2.24-5-5-5zm0-5c-5.52 0-10 4.48-10 10s4.48 10 10 10 10-4.48 10-10-4.48-10-10-10zm0 18a8 8 0 110-16 8 8 0 110 16z"
-})));
+var SvgSelect = function SvgSelect(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$5({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path$5 || (_path$5 = /*#__PURE__*/React.createElement("path", {
+    fillRule: "evenodd",
+    d: "M45 16a3 3 0 0 1 3 3v16a3 3 0 0 1-3 3H9a3 3 0 0 1-3-3V19a3 3 0 0 1 3-3h36zm0 2H9a1 1 0 0 0-1 1v16a1 1 0 0 0 1 1h36a1 1 0 0 0 1-1V19a1 1 0 0 0-1-1zm-12 7h9l-4.5 6-4.5-6z"
+  })));
+};
+var SelectIcon = SvgSelect;
 
+var _path$4, _path2$1;
 function _extends$4() { _extends$4 = 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$4.apply(this, arguments); }
-var SelectIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$4({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  d: "M45 16a3 3 0 013 3v16a3 3 0 01-3 3H9a3 3 0 01-3-3V19a3 3 0 013-3h36zm0 2H9a1 1 0 00-1 1v16a1 1 0 001 1h36a1 1 0 001-1V19a1 1 0 00-1-1zm-12 7h9l-4.5 6-4.5-6z"
-})));
+var SvgSpacer = function SvgSpacer(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$4({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "none"
+  }, props), _path$4 || (_path$4 = /*#__PURE__*/React.createElement("path", {
+    stroke: "#000",
+    strokeLinecap: "square",
+    strokeWidth: 2,
+    d: "M9 23h36M9 31h36"
+  })), _path2$1 || (_path2$1 = /*#__PURE__*/React.createElement("path", {
+    stroke: "#000",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    strokeWidth: 2,
+    d: "m23 17 4-4 4 4M31 37l-4 4-4-4"
+  })));
+};
+var SpacerIcon = SvgSpacer;
 
+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 TextIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$3({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("path", {
-  d: "M20.58 33.77h-3l-1.18-3.08H11l-1.1 3.08H7l5.27-13.54h2.89zm-5-5.36l-1.86-5-1.83 5zM22 20.23h5.41a15.47 15.47 0 012.4.14 3.42 3.42 0 011.41.55 3.47 3.47 0 011 1.14 3 3 0 01.42 1.58 3.26 3.26 0 01-1.91 2.94 3.63 3.63 0 011.91 1.22 3.28 3.28 0 01.66 2 4 4 0 01-.43 1.8 3.63 3.63 0 01-1.09 1.4 3.89 3.89 0 01-1.83.65q-.69.07-3.3.09H22zm2.73 2.25v3.13h3.8a1.79 1.79 0 001.1-.49 1.41 1.41 0 00.41-1 1.49 1.49 0 00-.35-1 1.54 1.54 0 00-1-.48c-.27 0-1.05-.05-2.34-.05zm0 5.39v3.62h2.57a11.52 11.52 0 001.88-.09 1.65 1.65 0 001-.54 1.6 1.6 0 00.38-1.14 1.75 1.75 0 00-.29-1 1.69 1.69 0 00-.86-.62 9.28 9.28 0 00-2.41-.23zm19.62.92l2.65.84a5.94 5.94 0 01-2 3.29A5.74 5.74 0 0141.38 34a5.87 5.87 0 01-4.44-1.84 7.09 7.09 0 01-1.73-5A7.43 7.43 0 0137 21.87 6 6 0 0141.54 20a5.64 5.64 0 014 1.47A5.33 5.33 0 0147 24l-2.7.65a2.8 2.8 0 00-2.86-2.27A3.09 3.09 0 0039 23.42a5.31 5.31 0 00-.93 3.5 5.62 5.62 0 00.93 3.65 3 3 0 002.4 1.09 2.72 2.72 0 001.82-.66 4 4 0 001.13-2.21z"
-})));
+var SvgText = function SvgText(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$3({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path$3 || (_path$3 = /*#__PURE__*/React.createElement("path", {
+    d: "M20.58 33.77h-3l-1.18-3.08H11l-1.1 3.08H7l5.27-13.54h2.89zm-5-5.36-1.86-5-1.83 5zM22 20.23h5.41a15.47 15.47 0 0 1 2.4.14 3.42 3.42 0 0 1 1.41.55 3.47 3.47 0 0 1 1 1.14 3 3 0 0 1 .42 1.58 3.26 3.26 0 0 1-1.91 2.94 3.63 3.63 0 0 1 1.91 1.22 3.28 3.28 0 0 1 .66 2 4 4 0 0 1-.43 1.8 3.63 3.63 0 0 1-1.09 1.4 3.89 3.89 0 0 1-1.83.65q-.69.07-3.3.09H22zm2.73 2.25v3.13h3.8a1.79 1.79 0 0 0 1.1-.49 1.41 1.41 0 0 0 .41-1 1.49 1.49 0 0 0-.35-1 1.54 1.54 0 0 0-1-.48c-.27 0-1.05-.05-2.34-.05zm0 5.39v3.62h2.57a11.52 11.52 0 0 0 1.88-.09 1.65 1.65 0 0 0 1-.54 1.6 1.6 0 0 0 .38-1.14 1.75 1.75 0 0 0-.29-1 1.69 1.69 0 0 0-.86-.62 9.28 9.28 0 0 0-2.41-.23zm19.62.92 2.65.84a5.94 5.94 0 0 1-2 3.29A5.74 5.74 0 0 1 41.38 34a5.87 5.87 0 0 1-4.44-1.84 7.09 7.09 0 0 1-1.73-5A7.43 7.43 0 0 1 37 21.87 6 6 0 0 1 41.54 20a5.64 5.64 0 0 1 4 1.47A5.33 5.33 0 0 1 47 24l-2.7.65a2.8 2.8 0 0 0-2.86-2.27A3.09 3.09 0 0 0 39 23.42a5.31 5.31 0 0 0-.93 3.5 5.62 5.62 0 0 0 .93 3.65 3 3 0 0 0 2.4 1.09 2.72 2.72 0 0 0 1.82-.66 4 4 0 0 0 1.13-2.21z"
+  })));
+};
+var TextIcon = SvgText;
 
+var _path$2;
 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 TextfieldIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$2({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  d: "M45 16a3 3 0 013 3v16a3 3 0 01-3 3H9a3 3 0 01-3-3V19a3 3 0 013-3h36zm0 2H9a1 1 0 00-1 1v16a1 1 0 001 1h36a1 1 0 001-1V19a1 1 0 00-1-1zm-32 4v10h-2V22h2z"
-})));
+var SvgTextfield = function SvgTextfield(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$2({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path$2 || (_path$2 = /*#__PURE__*/React.createElement("path", {
+    fillRule: "evenodd",
+    d: "M45 16a3 3 0 0 1 3 3v16a3 3 0 0 1-3 3H9a3 3 0 0 1-3-3V19a3 3 0 0 1 3-3h36zm0 2H9a1 1 0 0 0-1 1v16a1 1 0 0 0 1 1h36a1 1 0 0 0 1-1V19a1 1 0 0 0-1-1zm-32 4v10h-2V22h2z"
+  })));
+};
+var TextfieldIcon = SvgTextfield;
 
+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 TextareaIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends$1({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  d: "M45 13a3 3 0 013 3v22a3 3 0 01-3 3H9a3 3 0 01-3-3V16a3 3 0 013-3h36zm0 2H9a1 1 0 00-1 1v22a1 1 0 001 1h36a1 1 0 001-1V16a1 1 0 00-1-1zm-1.136 15.5l.849.849-6.364 6.364-.849-.849 6.364-6.364zm.264 3.5l.849.849-2.828 2.828-.849-.849L44.128 34zM13 19v10h-2V19h2z"
-})));
+var SvgTextarea = function SvgTextarea(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends$1({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path$1 || (_path$1 = /*#__PURE__*/React.createElement("path", {
+    fillRule: "evenodd",
+    d: "M45 13a3 3 0 0 1 3 3v22a3 3 0 0 1-3 3H9a3 3 0 0 1-3-3V16a3 3 0 0 1 3-3h36zm0 2H9a1 1 0 0 0-1 1v22a1 1 0 0 0 1 1h36a1 1 0 0 0 1-1V16a1 1 0 0 0-1-1zm-1.136 15.5.849.849-6.364 6.364-.849-.849 6.364-6.364zm.264 3.5.849.849-2.828 2.828-.849-.849L44.128 34zM13 19v10h-2V19h2z"
+  })));
+};
+var TextareaIcon = SvgTextarea;
 
+var _path, _path2;
 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 ImageIcon = (({
-  styles = {},
-  ...props
-}) => /*#__PURE__*/React.createElement("svg", _extends({
-  xmlns: "http://www.w3.org/2000/svg",
-  width: "54",
-  height: "54",
-  fill: "currentcolor"
-}, props), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  d: "M34.636 21.91A3.818 3.818 0 1127 21.908a3.818 3.818 0 017.636 0zm-2 0A1.818 1.818 0 1129 21.908a1.818 1.818 0 013.636 0z",
-  clipRule: "evenodd"
-}), /*#__PURE__*/React.createElement("path", {
-  fillRule: "evenodd",
-  d: "M15 13a2 2 0 00-2 2v24a2 2 0 002 2h24a2 2 0 002-2V15a2 2 0 00-2-2H15zm24 2H15v12.45l4.71-4.709a1.91 1.91 0 012.702 0l6.695 6.695 2.656-1.77a1.91 1.91 0 012.411.239L39 32.73V15zM15 39v-8.754a.975.975 0 00.168-.135l5.893-5.893 6.684 6.685a1.911 1.911 0 002.41.238l2.657-1.77 6.02 6.02c.052.051.108.097.168.135V39H15z",
-  clipRule: "evenodd"
-})));
+var SvgImage = function SvgImage(props) {
+  return /*#__PURE__*/React.createElement("svg", _extends({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path || (_path = /*#__PURE__*/React.createElement("path", {
+    fillRule: "evenodd",
+    d: "M34.636 21.91A3.818 3.818 0 1 1 27 21.908a3.818 3.818 0 0 1 7.636 0Zm-2 0A1.818 1.818 0 1 1 29 21.908a1.818 1.818 0 0 1 3.636 0Z",
+    clipRule: "evenodd"
+  })), _path2 || (_path2 = /*#__PURE__*/React.createElement("path", {
+    fillRule: "evenodd",
+    d: "M15 13a2 2 0 0 0-2 2v24a2 2 0 0 0 2 2h24a2 2 0 0 0 2-2V15a2 2 0 0 0-2-2H15Zm24 2H15v12.45l4.71-4.709a1.91 1.91 0 0 1 2.702 0l6.695 6.695 2.656-1.77a1.91 1.91 0 0 1 2.411.239L39 32.73V15ZM15 39v-8.754a.975.975 0 0 0 .168-.135l5.893-5.893 6.684 6.685a1.911 1.911 0 0 0 2.41.238l2.657-1.77 6.02 6.02c.052.051.108.097.168.135V39H15Z",
+    clipRule: "evenodd"
+  })));
+};
+var ImageIcon = SvgImage;
 
 const iconsByType = type => {
   return {
@@ -4930,6 +5745,7 @@ const iconsByType = type => {
     number: NumberIcon,
     radio: RadioIcon,
     select: SelectIcon,
+    spacer: SpacerIcon,
     taglist: TaglistIcon,
     text: TextIcon,
     textfield: TextfieldIcon,
@@ -4938,7 +5754,7 @@ const iconsByType = type => {
   }[type];
 };
 
-const formFields = [Button, Checkbox, Checklist, Default, Image, Numberfield, Datetime, Radio, Select, Taglist, Text, Textfield, Textarea];
+const formFields = [Button, Checkbox, Checklist, Default, Image, Numberfield, Datetime, Radio, Select, Spacer, Taglist, Text, Textfield, Textarea];
 
 class FormFields {
   constructor() {
@@ -5349,7 +6165,7 @@ class Form {
   * @internal
   */
   _getModules() {
-    return [ExpressionLanguageModule, MarkdownModule];
+    return [ExpressionLanguageModule, MarkdownModule, ViewerCommandsModule];
   }
 
   /**
@@ -5394,7 +6210,7 @@ class Form {
   }
 }
 
-const schemaVersion = 9;
+const schemaVersion = 10;
 
 /**
  * @typedef { import('./types').CreateFormOptions } CreateFormOptions
@@ -5419,5 +6235,5 @@ function createForm(options) {
   });
 }
 
-export { Button, Checkbox, Checklist, ConditionChecker, DATETIME_SUBTYPES, DATETIME_SUBTYPES_LABELS, DATETIME_SUBTYPE_PATH, DATE_DISALLOW_PAST_PATH, DATE_LABEL_PATH, Datetime, Default, ExpressionLanguageModule, FeelExpressionLanguage, FeelersTemplating, Form, FormComponent, FormContext$1 as FormContext, FormFieldRegistry, FormFields, FormLayouter, FormRenderContext$1 as FormRenderContext, Image, MINUTES_IN_DAY, MarkdownModule, MarkdownRenderer, Numberfield, Radio, Select, TIME_INTERVAL_PATH, TIME_LABEL_PATH, TIME_SERIALISINGFORMAT_LABELS, TIME_SERIALISING_FORMATS, TIME_SERIALISING_FORMAT_PATH, TIME_USE24H_PATH, Taglist, Text, Textarea, Textfield, VALUES_SOURCES, VALUES_SOURCES_DEFAULTS, VALUES_SOURCES_LABELS, VALUES_SOURCES_PATHS, VALUES_SOURCE_DEFAULT, clone, createForm, createFormContainer, createInjector, findErrors, formFields, generateIdForType, generateIndexForType, getSchemaVariables, getValuesSource, iconsByType, isRequired, pathParse, pathStringify, pathsEqual, schemaVersion };
+export { Button, Checkbox, Checklist, ConditionChecker, DATETIME_SUBTYPES, DATETIME_SUBTYPES_LABELS, DATETIME_SUBTYPE_PATH, DATE_DISALLOW_PAST_PATH, DATE_LABEL_PATH, Datetime, Default, ExpressionLanguageModule, FeelExpressionLanguage, FeelersTemplating, Form, FormComponent, FormContext$1 as FormContext, FormFieldRegistry, FormFields, FormLayouter, FormRenderContext$1 as FormRenderContext, Image, MINUTES_IN_DAY, MarkdownModule, MarkdownRenderer, Numberfield, Radio, Select, Spacer, TIME_INTERVAL_PATH, TIME_LABEL_PATH, TIME_SERIALISINGFORMAT_LABELS, TIME_SERIALISING_FORMATS, TIME_SERIALISING_FORMAT_PATH, TIME_USE24H_PATH, Taglist, Text, Textarea, Textfield, VALUES_SOURCES, VALUES_SOURCES_DEFAULTS, VALUES_SOURCES_LABELS, VALUES_SOURCES_PATHS, VALUES_SOURCE_DEFAULT, ViewerCommands, ViewerCommandsModule, clone, createForm, createFormContainer, createInjector, findErrors, formFields, generateIdForType, generateIndexForType, getSchemaVariables, getValuesSource, iconsByType, isRequired, pathParse, pathStringify, pathsEqual, schemaVersion };
 //# sourceMappingURL=index.es.js.map