@bpmn-io/form-js-viewer 1.0.0 → 1.3.0-alpha.0

package/dist/index.cjs

@@ -2,10 +2,9 @@
 
 var Ids = require('ids');
 var minDash = require('min-dash');
+var Big = require('big.js');
 var feelin = require('feelin');
 var feelers = require('feelers');
-var showdown = require('showdown');
-var Big = require('big.js');
 var classNames = require('classnames');
 var jsxRuntime = require('preact/jsx-runtime');
 var hooks = require('preact/hooks');
@@ -14,6 +13,7 @@ var React = require('preact/compat');
 var flatpickr = require('flatpickr');
 var Markup = require('preact-markup');
 var didi = require('didi');
+var showdown = require('showdown');
 
 function _interopNamespaceDefault(e) {
   var n = Object.create(null);
@@ -34,15 +34,15 @@ function _interopNamespaceDefault(e) {
 
 var React__namespace = /*#__PURE__*/_interopNamespaceDefault(React);
 
-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' ? feelin.parseExpressions(feelString) : feelin.parseUnaryTests(feelString);
+  const tree = feelFlavour === 'expression' ? feelin.parseExpression(feelString) : feelin.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)] : [];
@@ -55,34 +55,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
@@ -128,11 +132,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;
@@ -151,13 +155,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 = [{
@@ -180,7 +184,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 {
@@ -188,25 +230,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 minDash.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 {
@@ -221,13 +263,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) {
@@ -252,23 +294,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 minDash.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)) {
@@ -294,17 +336,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 {
@@ -319,22 +361,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
@@ -365,47 +407,271 @@ class FeelersTemplating {
 }
 FeelersTemplating.$inject = [];
 
-/**
- * @typedef {object} Condition
- * @property {string} [hide]
+// 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 (minDash.get(field, VALUES_SOURCES_PATHS[source]) !== undefined) {
+      return source;
+    }
+  }
+  return VALUES_SOURCE_DEFAULT;
+}
+
+function createInjector(bootstrapModules) {
+  const injector = new didi.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 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]);
+}
+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 getAllComponents = node => {
+    const components = [];
+    if (node.components) {
+      node.components.forEach(component => {
+        components.push(component);
+        components.push(...getAllComponents(component));
+      });
+    }
+    return components;
+  };
+  const variables = getAllComponents(schema).reduce((variables, component) => {
+    const {
+      valuesKey
+    } = component;
+
+    // collect input-only variables
+    if (inputs) {
+      if (valuesKey) {
+        variables = [...variables, valuesKey];
+      }
+      EXPRESSION_PROPERTIES.forEach(prop => {
+        const property = minDash.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 = minDash.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);
+  }, []);
+  const getBindingVariables = node => {
+    const bindingVariable = [];
+
+    // c.f. https://github.com/bpmn-io/form-js/issues/778 @Skaiir to remove?
+    if (node.type === 'button') {
+      return [];
+    } else if (node.key) {
+      return [node.key.split('.')[0]];
+    } else if (node.path) {
+      return [node.path.split('.')[0]];
+    } else if (node.components) {
+      node.components.forEach(component => {
+        bindingVariable.push(...getBindingVariables(component));
+      });
+    }
+    return bindingVariable;
+  };
+
+  // collect binding variables
+  if (inputs || outputs) {
+    variables.push(...getBindingVariables(schema));
+  }
+
+  // remove duplicates
+  return Array.from(new Set(variables));
+}
+function runRecursively(formField, fn) {
+  const components = formField.components || [];
+  components.forEach((component, index) => {
+    runRecursively(component, fn);
+  });
+  fn(formField);
+}
+
+/**
+ * @typedef {object} Condition
+ * @property {string} [hide]
  */
 
 class ConditionChecker {
-  constructor(formFieldRegistry, eventBus) {
+  constructor(formFieldRegistry, pathRegistry, eventBus) {
     this._formFieldRegistry = formFieldRegistry;
+    this._pathRegistry = pathRegistry;
     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();
-    const newProperties = {
-      ...properties
-    };
-    for (const {
-      key,
-      condition
-    } of conditions) {
-      const shouldRemove = this._checkHideCondition(condition, data);
-      if (shouldRemove) {
-        delete newProperties[key];
-      }
+    const newProperties = clone(properties);
+    const form = this._formFieldRegistry.getAll().find(field => field.type === 'default');
+    if (!form) {
+      throw new Error('form field registry has no form');
     }
+    this._pathRegistry.executeRecursivelyOnFields(form, ({
+      field,
+      isClosed,
+      context
+    }) => {
+      const {
+        conditional: condition
+      } = field;
+      context.isHidden = context.isHidden || condition && this._checkHideCondition(condition, data);
+
+      // only clear the leaf nodes, as groups may both point to the same path
+      if (context.isHidden && isClosed) {
+        const valuePath = this._pathRegistry.getValuePath(field);
+        this._clearObjectValueRecursively(valuePath, newProperties);
+      }
+    });
     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) {
@@ -426,12 +692,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) {
@@ -440,24 +706,18 @@ 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;
-    }, []);
+  _clearObjectValueRecursively(valuePath, obj) {
+    const workingValuePath = [...valuePath];
+    let recurse = false;
+    do {
+      minDash.set(obj, workingValuePath, undefined);
+      workingValuePath.pop();
+      const parentObject = minDash.get(obj, workingValuePath);
+      recurse = minDash.isObject(parentObject) && !minDash.values(parentObject).length && !!workingValuePath.length;
+    } while (recurse);
   }
 }
-ConditionChecker.$inject = ['formFieldRegistry', 'eventBus'];
+ConditionChecker.$inject = ['formFieldRegistry', 'pathRegistry', 'eventBus'];
 
 var ExpressionLanguageModule = {
   __init__: ['expressionLanguage', 'templating', 'conditionChecker'],
@@ -473,12 +733,12 @@ class MarkdownRenderer {
     this._converter = new showdown.Converter();
   }
 
-  /**
-   * Render markdown to HTML.
-   *
-   * @param {string} markdown - The markdown to render
-   *
-   * @returns {string} HTML
+  /**
+   * Render markdown to HTML.
+   *
+   * @param {string} markdown - The markdown to render
+   *
+   * @returns {string} HTML
    */
   render(markdown) {
     return this._converter.makeHtml(markdown);
@@ -491,6 +751,538 @@ var MarkdownModule = {
   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: minDash.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 = minDash.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]
+};
+
+class UpdateFieldValidationHandler {
+  constructor(form, validator) {
+    this._form = form;
+    this._validator = validator;
+  }
+  execute(context) {
+    const {
+      field,
+      value
+    } = context;
+    const {
+      errors
+    } = this._form._getState();
+    context.oldErrors = clone(errors);
+    const fieldErrors = this._validator.validateField(field, value);
+    const updatedErrors = minDash.set(errors, [field.id], fieldErrors.length ? fieldErrors : undefined);
+    this._form._setState({
+      errors: updatedErrors
+    });
+  }
+  revert(context) {
+    this._form._setState({
+      errors: context.oldErrors
+    });
+  }
+}
+UpdateFieldValidationHandler.$inject = ['form', 'validator'];
+
+class ViewerCommands {
+  constructor(commandStack, eventBus) {
+    this._commandStack = commandStack;
+    eventBus.on('form.init', () => {
+      this.registerHandlers();
+    });
+  }
+  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);
+  }
+}
+ViewerCommands.$inject = ['commandStack', 'eventBus'];
+
+var ViewerCommandsModule = {
+  __depends__: [commandModule],
+  __init__: ['viewerCommands'],
+  viewerCommands: ['type', ViewerCommands]
+};
+
 var FN_REF = '__fn';
 var DEFAULT_PRIORITY = 1000;
 var slice = Array.prototype.slice;
@@ -1094,8 +1886,8 @@ Validator.$inject = ['expressionLanguage', 'conditionChecker', 'form'];
 
 // helpers //////////
 
-/**
- * Helper function to evaluate optional FEEL validation values.
+/**
+ * Helper function to evaluate optional FEEL validation values.
  */
 function evaluateFEELValues(validate, expressionLanguage, conditionChecker, form) {
   const evaluatedValidate = {
@@ -1128,72 +1920,415 @@ function evaluateFEELValues(validate, expressionLanguage, conditionChecker, form
   return evaluatedValidate;
 }
 
-class FormFieldRegistry {
-  constructor(eventBus) {
-    this._eventBus = eventBus;
-    this._formFields = {};
-    eventBus.on('form.clear', () => this.clear());
-    this._ids = new Ids([32, 36, 1]);
-    this._keys = new Ids([32, 36, 1]);
+class Importer {
+  /**
+   * @constructor
+   * @param { import('./FormFieldRegistry').default } formFieldRegistry
+   * @param { import('./PathRegistry').default } pathRegistry
+   * @param { import('./FieldFactory').default } fieldFactory
+   * @param { import('./FormLayouter').default } formLayouter
+   */
+  constructor(formFieldRegistry, pathRegistry, fieldFactory, formLayouter) {
+    this._formFieldRegistry = formFieldRegistry;
+    this._pathRegistry = pathRegistry;
+    this._fieldFactory = fieldFactory;
+    this._formLayouter = formLayouter;
   }
-  add(formField) {
-    const {
-      id
-    } = formField;
-    if (this._formFields[id]) {
-      throw new Error(`form field with ID ${id} already exists`);
+
+  /**
+   * Import schema creating rows, fields, attaching additional
+   * information to each field and adding fields to the
+   * field registry.
+   *
+   * Additional information attached:
+   *
+   *   * `id` (unless present)
+   *   * `_parent`
+   *   * `_path`
+   *
+   * @param {any} schema
+   *
+   * @typedef {{ warnings: Error[], schema: any }} ImportResult
+   * @returns {ImportResult}
+   */
+  importSchema(schema) {
+    // TODO: Add warnings
+    const warnings = [];
+    try {
+      this._cleanup();
+      const importedSchema = this.importFormField(clone(schema));
+      this._formLayouter.calculateLayout(clone(importedSchema));
+      return {
+        schema: importedSchema,
+        warnings
+      };
+    } catch (err) {
+      this._cleanup();
+      err.warnings = warnings;
+      throw err;
     }
-    this._eventBus.fire('formField.add', {
-      formField
+  }
+  _cleanup() {
+    this._formLayouter.clear();
+    this._formFieldRegistry.clear();
+    this._pathRegistry.clear();
+  }
+
+  /**
+   * @param {{[x: string]: any}} fieldAttrs
+   * @param {String} [parentId]
+   * @param {number} [index]
+   *
+   * @return {any} field
+   */
+  importFormField(fieldAttrs, parentId, index) {
+    const {
+      components
+    } = fieldAttrs;
+    let parent, path;
+    if (parentId) {
+      parent = this._formFieldRegistry.get(parentId);
+    }
+
+    // set form field path
+    path = parent ? [...parent._path, 'components', index] : [];
+    const field = this._fieldFactory.create({
+      ...fieldAttrs,
+      _path: path,
+      _parent: parentId
+    }, false);
+    this._formFieldRegistry.add(field);
+    if (components) {
+      field.components = this.importFormFields(components, field.id);
+    }
+    return field;
+  }
+
+  /**
+   * @param {Array<any>} components
+   * @param {string} parentId
+   *
+   * @return {Array<any>} imported components
+   */
+  importFormFields(components, parentId) {
+    return components.map((component, index) => {
+      return this.importFormField(component, parentId, index);
     });
-    this._formFields[id] = formField;
   }
-  remove(formField) {
+}
+Importer.$inject = ['formFieldRegistry', 'pathRegistry', 'fieldFactory', 'formLayouter'];
+
+class FieldFactory {
+  /**
+   * @constructor
+   *
+   * @param  formFieldRegistry
+   * @param  formFields
+   */
+  constructor(formFieldRegistry, pathRegistry, formFields) {
+    this._formFieldRegistry = formFieldRegistry;
+    this._pathRegistry = pathRegistry;
+    this._formFields = formFields;
+  }
+  create(attrs, applyDefaults = true) {
     const {
-      id
-    } = formField;
-    if (!this._formFields[id]) {
-      return;
+      id,
+      type,
+      key,
+      path,
+      _parent
+    } = attrs;
+    const fieldDefinition = this._formFields.get(type);
+    if (!fieldDefinition) {
+      throw new Error(`form field of type <${type}> not supported`);
     }
-    this._eventBus.fire('formField.remove', {
-      formField
+    const {
+      config
+    } = fieldDefinition;
+    if (!config) {
+      throw new Error(`form field of type <${type}> has no config`);
+    }
+    if (id && this._formFieldRegistry._ids.assigned(id)) {
+      throw new Error(`form field with id <${id}> already exists`);
+    }
+
+    // ensure that we can claim the path
+
+    const parent = _parent && this._formFieldRegistry.get(_parent);
+    const parentPath = parent && this._pathRegistry.getValuePath(parent) || [];
+    if (config.keyed && key && !this._pathRegistry.canClaimPath([...parentPath, ...key.split('.')], true)) {
+      throw new Error(`binding path '${[...parentPath, key].join('.')}' is already claimed`);
+    }
+    if (config.pathed && path && !this._pathRegistry.canClaimPath([...parentPath, ...path.split('.')], false)) {
+      throw new Error(`binding path '${[...parentPath, ...path.split('.')].join('.')}' is already claimed`);
+    }
+    const labelAttrs = applyDefaults && config.label ? {
+      label: config.label
+    } : {};
+    const field = config.create({
+      ...labelAttrs,
+      ...attrs
     });
-    delete this._formFields[id];
+    this._ensureId(field);
+    if (config.keyed) {
+      this._ensureKey(field);
+    }
+    if (config.pathed && path) {
+      this._pathRegistry.claimPath(this._pathRegistry.getValuePath(field), false);
+    }
+    return field;
   }
-  get(id) {
-    return this._formFields[id];
+  _ensureId(field) {
+    if (field.id) {
+      this._formFieldRegistry._ids.claim(field.id, field);
+      return;
+    }
+    let prefix = 'Field';
+    if (field.type === 'default') {
+      prefix = 'Form';
+    }
+    field.id = this._formFieldRegistry._ids.nextPrefixed(`${prefix}_`, field);
+  }
+  _ensureKey(field) {
+    if (!field.key) {
+      let random;
+      const parent = this._formFieldRegistry.get(field._parent);
+
+      // ensure key uniqueness at level
+      do {
+        random = Math.random().toString(36).substring(7);
+      } while (parent && parent.components.some(child => child.key === random));
+      field.key = `${field.type}_${random}`;
+    }
+    this._pathRegistry.claimPath(this._pathRegistry.getValuePath(field), true);
   }
-  getAll() {
-    return Object.values(this._formFields);
+}
+FieldFactory.$inject = ['formFieldRegistry', 'pathRegistry', 'formFields'];
+
+/**
+ * The PathRegistry class manages a hierarchical structure of paths associated with form fields.
+ * It enables claiming, unclaiming, and validating paths within this structure.
+ *
+ * Example Tree Structure:
+ *
+ *   [
+ *     {
+ *       segment: 'root',
+ *       claimCount: 1,
+ *       children: [
+ *         {
+ *           segment: 'child1',
+ *           claimCount: 2,
+ *           children: null  // A leaf node (closed path)
+ *         },
+ *         {
+ *           segment: 'child2',
+ *           claimCount: 1,
+ *           children: [
+ *             {
+ *               segment: 'subChild1',
+ *               claimCount: 1,
+ *               children: []  // An open node (open path)
+ *             }
+ *           ]
+ *         }
+ *       ]
+ *     }
+ *   ]
+ */
+class PathRegistry {
+  constructor(formFieldRegistry, formFields) {
+    this._formFieldRegistry = formFieldRegistry;
+    this._formFields = formFields;
+    this._dataPaths = [];
   }
-  forEach(callback) {
-    this.getAll().forEach(formField => callback(formField));
+  canClaimPath(path, closed = false) {
+    let node = {
+      children: this._dataPaths
+    };
+    for (const segment of path) {
+      node = _getNextSegment(node, segment);
+
+      // if no node at that path, we can claim it no matter what
+      if (!node) {
+        return true;
+      }
+
+      // if we reach a leaf node, definitely not claimable
+      if (node.children === null) {
+        return false;
+      }
+    }
+
+    // if after all segments we reach a node with children, we can claim it only openly
+    return !closed;
+  }
+  claimPath(path, closed = false) {
+    if (!this.canClaimPath(path, closed)) {
+      throw new Error(`cannot claim path '${path.join('.')}'`);
+    }
+    let node = {
+      children: this._dataPaths
+    };
+    for (const segment of path) {
+      let child = _getNextSegment(node, segment);
+      if (!child) {
+        child = {
+          segment,
+          claimCount: 1,
+          children: []
+        };
+        node.children.push(child);
+      } else {
+        child.claimCount++;
+      }
+      node = child;
+    }
+    if (closed) {
+      node.children = null;
+    }
+  }
+  unclaimPath(path) {
+    // verification Pass
+    let node = {
+      children: this._dataPaths
+    };
+    for (const segment of path) {
+      const child = _getNextSegment(node, segment);
+      if (!child) {
+        throw new Error(`no open path found for '${path.join('.')}'`);
+      }
+      node = child;
+    }
+
+    // mutation Pass
+    node = {
+      children: this._dataPaths
+    };
+    for (const segment of path) {
+      const child = _getNextSegment(node, segment);
+      child.claimCount--;
+      if (child.claimCount === 0) {
+        node.children.splice(node.children.indexOf(child), 1);
+        break; // Abort early if claimCount reaches zero
+      }
+
+      node = child;
+    }
+  }
+
+  /**
+   * Applies a function (fn) recursively on a given field and its children.
+   *
+   * - `field`: Starting field object.
+   * - `fn`: Function to apply.
+   * - `context`: Optional object for passing data between calls.
+   *
+   * Stops early if `fn` returns `false`. Useful for traversing the form field tree.
+   *
+   * @returns {boolean} Success status based on function execution.
+   */
+  executeRecursivelyOnFields(field, fn, context = {}) {
+    let result = true;
+    const formFieldConfig = this._formFields.get(field.type).config;
+    if (formFieldConfig.keyed) {
+      const callResult = fn({
+        field,
+        isClosed: true,
+        context
+      });
+      return result && callResult;
+    } else if (formFieldConfig.pathed) {
+      const callResult = fn({
+        field,
+        isClosed: false,
+        context
+      });
+      result = result && callResult;
+    }
+    if (field.components) {
+      for (const child of field.components) {
+        const callResult = this.executeRecursivelyOnFields(child, fn, clone(context));
+        result = result && callResult;
+
+        // only stop executing if false is specifically returned, not if undefined
+        if (result === false) {
+          return result;
+        }
+      }
+    }
+    return result;
+  }
+
+  /**
+   * Generates an array representing the binding path to an underlying data object for a form field.
+   *
+   * @param {Object} field - The field object with properties: `key`, `path`, `id`, and optionally `_parent`.
+   * @param {Object} [options={}] - Configuration options.
+   * @param {Object} [options.replacements={}] - A map of field IDs to alternative path arrays.
+   * @param {Object} [options.cutoffNode] - The ID of the parent field at which to stop generating the path.
+   *
+   * @returns {(Array<string>|undefined)} An array of strings representing the binding path, or undefined if not determinable.
+   */
+  getValuePath(field, options = {}) {
+    const {
+      replacements = {},
+      cutoffNode = null
+    } = options;
+    let localValuePath = [];
+    const hasReplacement = Object.prototype.hasOwnProperty.call(replacements, field.id);
+    const formFieldConfig = this._formFields.get(field.type).config;
+    if (hasReplacement) {
+      const replacement = replacements[field.id];
+      if (replacement === null || replacement === undefined || replacement === '') {
+        localValuePath = [];
+      } else if (typeof replacement === 'string') {
+        localValuePath = replacement.split('.');
+      } else if (Array.isArray(replacement)) {
+        localValuePath = replacement;
+      } else {
+        throw new Error(`replacements for field ${field.id} must be a string, array or null/undefined`);
+      }
+    } else if (formFieldConfig.keyed) {
+      localValuePath = field.key.split('.');
+    } else if (formFieldConfig.pathed && field.path) {
+      localValuePath = field.path.split('.');
+    }
+    if (field._parent && field._parent !== cutoffNode) {
+      const parent = this._formFieldRegistry.get(field._parent);
+      return [...(this.getValuePath(parent, options) || []), ...localValuePath];
+    }
+    return localValuePath;
   }
   clear() {
-    this._formFields = {};
-    this._ids.clear();
-    this._keys.clear();
+    this._dataPaths = [];
   }
 }
-FormFieldRegistry.$inject = ['eventBus'];
+const _getNextSegment = (node, segment) => {
+  if (minDash.isArray(node.children)) {
+    return node.children.find(node => node.segment === segment) || null;
+  }
+  return null;
+};
+PathRegistry.$inject = ['formFieldRegistry', 'formFields'];
 
-/**
- * @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) {
@@ -1203,8 +2338,8 @@ class FormLayouter {
     this._eventBus = eventBus;
   }
 
-  /**
-   * @param {FormRow} row
+  /**
+   * @param {FormRow} row
    */
   addRow(formFieldId, row) {
     let rowsPerComponent = this._rows.find(r => r.formFieldId === formFieldId);
@@ -1218,18 +2353,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 => {
@@ -1240,9 +2375,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);
@@ -1252,22 +2387,22 @@ class FormLayouter {
     return rowsForField.rows;
   }
 
-  /**
-   * @returns {string}
+  /**
+   * @returns {string}
    */
   nextRowId() {
     return this._ids.nextPrefixed('Row_');
   }
 
-  /**
-   * @param {any} formField
+  /**
+   * @param {any} formField
    */
   calculateLayout(formField) {
     const {
       type,
       components
     } = formField;
-    if (type !== 'default' || !components) {
+    if (type !== 'default' && type !== 'group' || !components) {
       return;
     }
 
@@ -1289,363 +2424,85 @@ class FormLayouter {
       rows: this._rows
     });
   }
-  clear() {
-    this._rows = [];
-    this._ids.clear();
-
-    // fire event to notify interested parties
-    this._eventBus.fire('form.layoutCleared');
-  }
-}
-FormLayouter.$inject = ['eventBus'];
-
-// helpers //////
-
-function groupByRow(components, ids) {
-  return minDash.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 minDash.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',
-  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 (minDash.get(field, VALUES_SOURCES_PATHS[source]) !== undefined) {
-      return source;
-    }
-  }
-  return VALUES_SOURCE_DEFAULT;
-}
-
-function createInjector(bootstrapModules) {
-  const injector = new didi.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, expressionLanguage = new FeelExpressionLanguage(null), templating = new FeelersTemplating()) {
-  if (!schema.components) {
-    return [];
-  }
-  const variables = schema.components.reduce((variables, component) => {
-    const {
-      key,
-      valuesKey,
-      type
-    } = component;
-    if (['button'].includes(type)) {
-      return variables;
-    }
-    if (key) {
-      variables = [...variables, key];
-    }
-    if (valuesKey) {
-      variables = [...variables, valuesKey];
-    }
-    EXPRESSION_PROPERTIES.forEach(prop => {
-      const property = minDash.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 = minDash.get(component, prop.split('.'));
-      if (property && !expressionLanguage.isExpression(property) && templating.isTemplate(property)) {
-        const templateVariables = templating.getVariableNames(property);
-        variables = [...variables, ...templateVariables];
-      }
-    });
-    return variables;
-  }, []);
-
-  // remove duplicates
-  return Array.from(new Set(variables));
-}
-
-class Importer {
-  /**
-   * @constructor
-   * @param { import('../core').FormFieldRegistry } formFieldRegistry
-   * @param { import('../render/FormFields').default } formFields
-   * @param { import('../core').FormLayouter } formLayouter
-   */
-  constructor(formFieldRegistry, formFields, formLayouter) {
-    this._formFieldRegistry = formFieldRegistry;
-    this._formFields = formFields;
-    this._formLayouter = formLayouter;
-  }
+  clear() {
+    this._rows = [];
+    this._ids.clear();
 
-  /**
-   * 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
-    const warnings = [];
-    try {
-      this._formLayouter.clear();
-      const importedSchema = this.importFormField(clone(schema)),
-        initializedData = this.initializeFieldValues(clone(data));
-      this._formLayouter.calculateLayout(clone(importedSchema));
-      return {
-        warnings,
-        schema: importedSchema,
-        data: initializedData
-      };
-    } catch (err) {
-      err.warnings = warnings;
-      throw err;
-    }
+    // fire event to notify interested parties
+    this._eventBus.fire('form.layoutCleared');
   }
+}
+FormLayouter.$inject = ['eventBus'];
 
-  /**
-   * @param {any} formField
-   * @param {string} [parentId]
-   *
-   * @return {any} importedField
-   */
-  importFormField(formField, parentId) {
+// helpers //////
+
+function groupByRow(components, ids) {
+  return minDash.groupBy(components, c => {
+    // mitigate missing row by creating new (handle legacy)
     const {
-      components,
-      key,
-      type,
-      id = generateIdForType(type)
-    } = formField;
-    if (parentId) {
-      // set form field parent
-      formField._parent = parentId;
-    }
-    if (!this._formFields.get(type)) {
-      throw new Error(`form field of type <${type}> not supported`);
+      layout
+    } = c;
+    if (!layout || !layout.row) {
+      return ids.nextPrefixed('Row_');
     }
-    if (key) {
-      // validate <key> uniqueness
-      if (this._formFieldRegistry._keys.assigned(key)) {
-        throw new Error(`form field with key <${key}> already exists`);
-      }
-      this._formFieldRegistry._keys.claim(key, formField);
+    return layout.row;
+  });
+}
 
-      // TODO: buttons should not have key
-      if (type !== 'button') {
-        // set form field path
-        formField._path = [key];
-      }
-    }
-    if (id) {
-      // validate <id> uniqueness
-      if (this._formFieldRegistry._ids.assigned(id)) {
-        throw new Error(`form field with id <${id}> already exists`);
-      }
-      this._formFieldRegistry._ids.claim(id, formField);
-    }
+/**
+ * @param {Array<FormRows>} formRows
+ * @returns {Array<FormRow>}
+ */
+function allRows(formRows) {
+  return minDash.flatten(formRows.map(c => c.rows));
+}
 
-    // set form field ID
-    formField.id = id;
-    this._formFieldRegistry.add(formField);
-    if (components) {
-      this.importFormFields(components, id);
+class FormFieldRegistry {
+  constructor(eventBus) {
+    this._eventBus = eventBus;
+    this._formFields = {};
+    eventBus.on('form.clear', () => this.clear());
+    this._ids = new Ids([32, 36, 1]);
+  }
+  add(formField) {
+    const {
+      id
+    } = formField;
+    if (this._formFields[id]) {
+      throw new Error(`form field with ID ${id} already exists`);
     }
-    return formField;
+    this._eventBus.fire('formField.add', {
+      formField
+    });
+    this._formFields[id] = formField;
   }
-  importFormFields(components, parentId) {
-    components.forEach(component => {
-      this.importFormField(component, parentId);
+  remove(formField) {
+    const {
+      id
+    } = formField;
+    if (!this._formFields[id]) {
+      return;
+    }
+    this._eventBus.fire('formField.remove', {
+      formField
     });
+    delete this._formFields[id];
   }
-
-  /**
-   * @param {Object} data
-   *
-   * @return {Object} initializedData
-   */
-  initializeFieldValues(data) {
-    return this._formFieldRegistry.getAll().reduce((initializedData, formField) => {
-      const {
-        defaultValue,
-        _path,
-        type
-      } = formField;
-
-      // try to get value from data
-      // if unavailable - try to get default value from form field
-      // if unavailable - get empty value from form field
-
-      if (_path) {
-        const {
-          config: fieldConfig
-        } = this._formFields.get(type);
-        let valueData = minDash.get(data, _path);
-        if (!minDash.isUndefined(valueData) && fieldConfig.sanitizeValue) {
-          valueData = fieldConfig.sanitizeValue({
-            formField,
-            data,
-            value: valueData
-          });
-        }
-        const initializedFieldValue = !minDash.isUndefined(valueData) ? valueData : !minDash.isUndefined(defaultValue) ? defaultValue : fieldConfig.emptyValue;
-        initializedData = {
-          ...initializedData,
-          [_path[0]]: initializedFieldValue
-        };
-      }
-      return initializedData;
-    }, data);
+  get(id) {
+    return this._formFields[id];
+  }
+  getAll() {
+    return Object.values(this._formFields);
+  }
+  forEach(callback) {
+    this.getAll().forEach(formField => callback(formField));
+  }
+  clear() {
+    this._formFields = {};
+    this._ids.clear();
   }
 }
-Importer.$inject = ['formFieldRegistry', 'formFields', 'formLayouter'];
-
-var importModule = {
-  importer: ['type', Importer]
-};
+FormFieldRegistry.$inject = ['eventBus'];
 
 function formFieldClasses(type, {
   errors = [],
@@ -1679,7 +2536,7 @@ function prefixId(id, formId) {
   return `fjs-form-${id}`;
 }
 
-const type$b = 'button';
+const type$c = 'button';
 function Button(props) {
   const {
     disabled,
@@ -1689,7 +2546,7 @@ function Button(props) {
     action = 'submit'
   } = field;
   return jsxRuntime.jsx("div", {
-    class: formFieldClasses(type$b),
+    class: formFieldClasses(type$c),
     children: jsxRuntime.jsx("button", {
       class: "fjs-button",
       type: action,
@@ -1699,8 +2556,8 @@ function Button(props) {
   });
 }
 Button.config = {
-  type: type$b,
-  keyed: true,
+  type: type$c,
+  keyed: false,
   label: 'Button',
   group: 'action',
   create: (options = {}) => ({
@@ -1710,6 +2567,9 @@ Button.config = {
 };
 
 const FormRenderContext = preact.createContext({
+  EmptyRoot: props => {
+    return null;
+  },
   Empty: props => {
     return null;
   },
@@ -1739,15 +2599,19 @@ const FormRenderContext = preact.createContext({
       class: props.class,
       children: props.children
     });
+  },
+  hoveredId: [],
+  setHoveredId: newValue => {
+    console.log(`setHoveredId not defined, called with '${newValue}'`);
   }
 });
 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 = preact.createContext({
@@ -1763,10 +2627,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 {
@@ -1783,12 +2647,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);
@@ -1798,13 +2662,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();
@@ -1833,16 +2697,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');
@@ -1860,16 +2724,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();
@@ -1882,17 +2746,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);
@@ -1959,11 +2823,12 @@ function Label(props) {
   });
 }
 
-const type$a = 'checkbox';
+const type$b = 'checkbox';
 function Checkbox(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value = false
@@ -1990,7 +2855,7 @@ function Checkbox(props) {
   } = hooks.useContext(FormContext$1);
   const errorMessageId = errors.length === 0 ? undefined : `${prefixId(id, formId)}-error-message`;
   return jsxRuntime.jsxs("div", {
-    class: classNames(formFieldClasses(type$a, {
+    class: classNames(formFieldClasses(type$b, {
       errors,
       disabled,
       readonly
@@ -2009,6 +2874,7 @@ function Checkbox(props) {
         id: prefixId(id, formId),
         type: "checkbox",
         onChange: onChange,
+        onBlur: onBlur,
         "aria-describedby": errorMessageId
       })
     }), jsxRuntime.jsx(Description, {
@@ -2020,7 +2886,7 @@ function Checkbox(props) {
   });
 }
 Checkbox.config = {
-  type: type$a,
+  type: type$b,
   keyed: true,
   label: 'Checkbox',
   group: 'selection',
@@ -2078,9 +2944,24 @@ function _isReadableType(value) {
 function _isValueSomething(value) {
   return value || value === 0 || value === false;
 }
+function createEmptyOptions(options = {}) {
+  const defaults = {};
 
-/**
- * @enum { String }
+  // provide default values if valuesKey and valuesExpression are not set
+  if (!options.valuesKey && !options.valuesExpression) {
+    defaults.values = [{
+      label: 'Value',
+      value: 'value'
+    }];
+  }
+  return {
+    ...defaults,
+    ...options
+  };
+}
+
+/**
+ * @enum { String }
  */
 const LOAD_STATES = {
   LOADING: 'loading',
@@ -2088,17 +2969,17 @@ 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 {
@@ -2363,11 +3244,12 @@ function sanitizeMultiSelectValue(options) {
   }
 }
 
-const type$9 = 'checklist';
+const type$a = 'checklist';
 function Checklist(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value = []
@@ -2378,6 +3260,7 @@ function Checklist(props) {
     label,
     validate = {}
   } = field;
+  const outerDivRef = hooks.useRef();
   const {
     required
   } = validate;
@@ -2393,6 +3276,12 @@ function Checklist(props) {
       value: newValue
     });
   };
+  const onCheckboxBlur = e => {
+    if (outerDivRef.current.contains(e.relatedTarget)) {
+      return;
+    }
+    onBlur();
+  };
   const {
     state: loadState,
     values: options
@@ -2402,11 +3291,12 @@ function Checklist(props) {
   } = hooks.useContext(FormContext$1);
   const errorMessageId = errors.length === 0 ? undefined : `${prefixId(id, formId)}-error-message`;
   return jsxRuntime.jsxs("div", {
-    class: classNames(formFieldClasses(type$9, {
+    class: classNames(formFieldClasses(type$a, {
       errors,
       disabled,
       readonly
     })),
+    ref: outerDivRef,
     children: [jsxRuntime.jsx(Label, {
       label: label,
       required: required
@@ -2426,6 +3316,7 @@ function Checklist(props) {
           id: prefixId(`${id}-${index}`, formId),
           type: "checkbox",
           onClick: () => toggleCheckbox(v.value),
+          onBlur: onCheckboxBlur,
           "aria-describedby": errorMessageId
         })
       }, `${id}-${index}`);
@@ -2438,27 +3329,13 @@ function Checklist(props) {
   });
 }
 Checklist.config = {
-  type: type$9,
+  type: type$a,
   keyed: true,
   label: 'Checklist',
   group: 'selection',
   emptyValue: [],
   sanitizeValue: sanitizeMultiSelectValue,
-  create: (options = {}) => {
-    const defaults = {};
-
-    // provide default values if valuesKey isn't set
-    if (!options.valuesKey) {
-      defaults.values = [{
-        label: 'Value',
-        value: 'value'
-      }];
-    }
-    return {
-      ...defaults,
-      ...options
-    };
-  }
+  create: createEmptyOptions
 };
 
 const noop$1 = () => false;
@@ -2468,8 +3345,11 @@ function FormField(props) {
     onChange
   } = props;
   const formFields = useService('formFields'),
+    viewerCommands = useService('viewerCommands', false),
+    pathRegistry = useService('pathRegistry'),
     form = useService('form');
   const {
+    initialData,
     data,
     errors,
     properties
@@ -2483,12 +3363,23 @@ function FormField(props) {
   if (!FormFieldComponent) {
     throw new Error(`cannot render field <${field.type}>`);
   }
-  const value = minDash.get(data, field._path);
-  const fieldErrors = findErrors(errors, field._path);
+  const valuePath = hooks.useMemo(() => pathRegistry.getValuePath(field), [field, pathRegistry]);
+  const initialValue = hooks.useMemo(() => minDash.get(initialData, valuePath), [initialData, valuePath]);
   const readonly = useReadonly(field, properties);
+  const value = minDash.get(data, valuePath);
 
   // add precedence: global readonly > form field disabled
   const disabled = !properties.readOnly && (properties.disabled || field.disabled || false);
+  const onBlur = hooks.useCallback(() => {
+    if (viewerCommands) {
+      viewerCommands.updateFieldValidation(field, value);
+    }
+  }, [viewerCommands, field, value]);
+  hooks.useEffect(() => {
+    if (viewerCommands && initialValue) {
+      viewerCommands.updateFieldValidation(field, initialValue);
+    }
+  }, [viewerCommands, field, initialValue]);
   const hidden = useCondition(field.conditional && field.conditional.hide || null);
   if (hidden) {
     return jsxRuntime.jsx(Empty, {});
@@ -2502,8 +3393,9 @@ function FormField(props) {
       children: jsxRuntime.jsx(FormFieldComponent, {
         ...props,
         disabled: disabled,
-        errors: fieldErrors,
+        errors: errors[field.id],
         onChange: disabled || readonly ? noop$1 : onChange,
+        onBlur: disabled || readonly ? noop$1 : onBlur,
         readonly: readonly,
         value: value
       })
@@ -2511,14 +3403,14 @@ function FormField(props) {
   });
 }
 
-function Default(props) {
+function Grid(props) {
   const {
     Children,
-    Empty,
     Row
   } = hooks.useContext(FormRenderContext$1);
   const {
-    field
+    field,
+    Empty
   } = props;
   const {
     id,
@@ -2555,7 +3447,20 @@ function Default(props) {
     }), components.length ? null : jsxRuntime.jsx(Empty, {})]
   });
 }
-Default.config = {
+
+function FormComponent$1(props) {
+  const {
+    EmptyRoot
+  } = hooks.useContext(FormRenderContext$1);
+  const fullProps = {
+    ...props,
+    Empty: EmptyRoot
+  };
+  return jsxRuntime.jsx(Grid, {
+    ...fullProps
+  });
+}
+FormComponent$1.config = {
   type: 'default',
   keyed: false,
   label: null,
@@ -2566,16 +3471,16 @@ Default.config = {
   })
 };
 
-var _path$g;
-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 _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__namespace.createElement("svg", _extends$j({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$k({
     xmlns: "http://www.w3.org/2000/svg",
     width: 14,
     height: 15,
     fill: "none",
     viewBox: "0 0 28 30"
-  }, props), _path$g || (_path$g = /*#__PURE__*/React__namespace.createElement("path", {
+  }, props), _path$h || (_path$h = /*#__PURE__*/React__namespace.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",
@@ -2584,6 +3489,74 @@ var SvgCalendar = function SvgCalendar(props) {
 };
 var CalendarIcon = SvgCalendar;
 
+/**
+ * Returns date format for the provided locale.
+ * If the locale is not provided, uses the browser's locale.
+ *
+ * @param {string} [locale] - The locale to get date format for.
+ * @returns {string} The date format for the locale.
+ */
+function getLocaleDateFormat(locale = 'default') {
+  const parts = new Intl.DateTimeFormat(locale).formatToParts(new Date(Date.UTC(2020, 5, 5)));
+  return parts.map(part => {
+    const len = part.value.length;
+    switch (part.type) {
+      case 'day':
+        return 'd'.repeat(len);
+      case 'month':
+        return 'M'.repeat(len);
+      case 'year':
+        return 'y'.repeat(len);
+      default:
+        return part.value;
+    }
+  }).join('');
+}
+
+/**
+ * Returns readable date format for the provided locale.
+ * If the locale is not provided, uses the browser's locale.
+ *
+ * @param {string} [locale] - The locale to get readable date format for.
+ * @returns {string} The readable date format for the locale.
+ */
+function getLocaleReadableDateFormat(locale) {
+  let format = getLocaleDateFormat(locale).toLowerCase();
+
+  // Ensure month is in 'mm' format
+  if (!format.includes('mm')) {
+    format = format.replace('m', 'mm');
+  }
+
+  // Ensure day is in 'dd' format
+  if (!format.includes('dd')) {
+    format = format.replace('d', 'dd');
+  }
+  return format;
+}
+
+/**
+ * Returns flatpickr config for the provided locale.
+ * If the locale is not provided, uses the browser's locale.
+ *
+ * @param {string} [locale] - The locale to get flatpickr config for.
+ * @returns {object} The flatpickr config for the locale.
+ */
+function getLocaleDateFlatpickrConfig(locale) {
+  return flatpickerizeDateFormat(getLocaleDateFormat(locale));
+}
+function flatpickerizeDateFormat(dateFormat) {
+  const useLeadingZero = {
+    day: dateFormat.includes('dd'),
+    month: dateFormat.includes('MM'),
+    year: dateFormat.includes('yyyy')
+  };
+  dateFormat = useLeadingZero.day ? dateFormat.replace('dd', 'd') : dateFormat.replace('d', 'j');
+  dateFormat = useLeadingZero.month ? dateFormat.replace('MM', 'm') : dateFormat.replace('M', 'n');
+  dateFormat = useLeadingZero.year ? dateFormat.replace('yyyy', 'Y') : dateFormat.replace('yy', 'y');
+  return dateFormat;
+}
+
 function InputAdorner(props) {
   const {
     pre,
@@ -2627,6 +3600,7 @@ function Datepicker(props) {
     id,
     label,
     collapseLabelOnEmpty,
+    onDateTimeBlur,
     formId,
     required,
     disabled,
@@ -2657,7 +3631,7 @@ function Datepicker(props) {
   hooks.useEffect(() => {
     let config = {
       allowInput: true,
-      dateFormat: 'm/d/Y',
+      dateFormat: getLocaleDateFlatpickrConfig(),
       static: true,
       clickOpens: false,
       // TODO: support dates prior to 1900 (https://github.com/bpmn-io/form-js/issues/533)
@@ -2721,7 +3695,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 jsxRuntime.jsxs("div", {
     class: "fjs-datetime-subsection",
@@ -2748,7 +3723,7 @@ function Datepicker(props) {
           class: "fjs-input",
           disabled: disabled,
           readOnly: readonly,
-          placeholder: "mm/dd/yyyy",
+          placeholder: getLocaleReadableDateFormat(),
           autoComplete: "off",
           onFocus: onInputFocus,
           onKeyDown: onInputKeyDown,
@@ -2763,19 +3738,19 @@ function Datepicker(props) {
   });
 }
 
-var _path$f, _path2$3;
-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 _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__namespace.createElement("svg", _extends$i({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$j({
     xmlns: "http://www.w3.org/2000/svg",
     width: 16,
     height: 16,
     fill: "none",
     viewBox: "0 0 28 29"
-  }, props), _path$f || (_path$f = /*#__PURE__*/React__namespace.createElement("path", {
+  }, props), _path$g || (_path$g = /*#__PURE__*/React__namespace.createElement("path", {
     fill: "currentColor",
     d: "M13 14.41 18.59 20 20 18.59l-5-5.01V5h-2v9.41Z"
-  })), _path2$3 || (_path2$3 = /*#__PURE__*/React__namespace.createElement("path", {
+  })), _path2$4 || (_path2$4 = /*#__PURE__*/React__namespace.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",
@@ -2884,6 +3859,7 @@ function Timepicker(props) {
     id,
     label,
     collapseLabelOnEmpty,
+    onDateTimeBlur,
     formId,
     required,
     disabled,
@@ -2983,6 +3959,7 @@ function Timepicker(props) {
   const onInputBlur = e => {
     setDropdownIsOpen(false);
     propagateRawToMinute();
+    onDateTimeBlur(e);
   };
   const onDropdownValueSelected = value => {
     setDropdownIsOpen(false);
@@ -3038,11 +4015,12 @@ function Timepicker(props) {
   });
 }
 
-const type$8 = 'datetime';
+const type$9 = 'datetime';
 function Datetime(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     onChange,
     readonly,
@@ -3066,6 +4044,7 @@ function Datetime(props) {
   const {
     formId
   } = hooks.useContext(FormContext$1);
+  const dateTimeGroupRef = hooks.useRef();
   const getNullDateTime = () => ({
     date: new Date(Date.parse(null)),
     time: null
@@ -3076,6 +4055,12 @@ function Datetime(props) {
   const isValidTime = time => !isNaN(parseInt(time));
   const useDatePicker = hooks.useMemo(() => subtype === DATETIME_SUBTYPES.DATE || subtype === DATETIME_SUBTYPES.DATETIME, [subtype]);
   const useTimePicker = hooks.useMemo(() => subtype === DATETIME_SUBTYPES.TIME || subtype === DATETIME_SUBTYPES.DATETIME, [subtype]);
+  const onDateTimeBlur = hooks.useCallback(e => {
+    if (e.relatedTarget && dateTimeGroupRef.current.contains(e.relatedTarget)) {
+      return;
+    }
+    onBlur();
+  }, [onBlur]);
   hooks.useEffect(() => {
     let {
       date,
@@ -3167,6 +4152,7 @@ function Datetime(props) {
     id,
     label: dateLabel,
     collapseLabelOnEmpty: !timeLabel,
+    onDateTimeBlur,
     formId,
     required,
     disabled,
@@ -3180,6 +4166,7 @@ function Datetime(props) {
     id,
     label: timeLabel,
     collapseLabelOnEmpty: !dateLabel,
+    onDateTimeBlur,
     formId,
     required,
     disabled,
@@ -3191,13 +4178,14 @@ function Datetime(props) {
     'aria-describedby': errorMessageId
   };
   return jsxRuntime.jsxs("div", {
-    class: formFieldClasses(type$8, {
+    class: formFieldClasses(type$9, {
       errors: allErrors,
       disabled,
       readonly
     }),
     children: [jsxRuntime.jsxs("div", {
       class: classNames('fjs-vertical-group'),
+      ref: dateTimeGroupRef,
       children: [useDatePicker && jsxRuntime.jsx(Datepicker, {
         ...datePickerProps
       }), useTimePicker && useDatePicker && jsxRuntime.jsx("div", {
@@ -3214,7 +4202,7 @@ function Datetime(props) {
   });
 }
 Datetime.config = {
-  type: type$8,
+  type: type$9,
   keyed: true,
   label: 'Date time',
   group: 'basic-input',
@@ -3231,10 +4219,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 jsxRuntime.jsxs("svg", {
@@ -3356,6 +4344,52 @@ function FormComponent(props) {
   });
 }
 
+function Group(props) {
+  const {
+    field
+  } = props;
+  const {
+    label,
+    id,
+    type,
+    showOutline
+  } = field;
+  const {
+    formId
+  } = hooks.useContext(FormContext$1);
+  const {
+    Empty
+  } = hooks.useContext(FormRenderContext$1);
+  const fullProps = {
+    ...props,
+    Empty
+  };
+  return jsxRuntime.jsxs("div", {
+    className: classNames(formFieldClasses(type), {
+      'fjs-outlined': showOutline
+    }),
+    role: "group",
+    "aria-labelledby": prefixId(id, formId),
+    children: [jsxRuntime.jsx(Label, {
+      id: prefixId(id, formId),
+      label: label
+    }), jsxRuntime.jsx(Grid, {
+      ...fullProps
+    })]
+  });
+}
+Group.config = {
+  type: 'group',
+  pathed: true,
+  label: 'Group',
+  group: 'presentation',
+  create: (options = {}) => ({
+    components: [],
+    showOutline: true,
+    ...options
+  })
+};
+
 const NODE_TYPE_TEXT = 3,
   NODE_TYPE_ELEMENT = 1;
 const ALLOWED_NODES = ['h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'span', 'em', 'a', 'p', 'div', 'ul', 'ol', 'li', 'hr', 'blockquote', 'img', 'pre', 'code', 'br', 'strong', 'table', 'thead', 'tbody', 'tr', 'th', 'td'];
@@ -3366,11 +4400,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
@@ -3388,29 +4422,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
@@ -3454,13 +4488,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
@@ -3483,9 +4517,9 @@ 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); }
+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__namespace.createElement("svg", _extends$h({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$i({
     xmlns: "http://www.w3.org/2000/svg",
     xmlSpace: "preserve",
     width: 64,
@@ -3524,7 +4558,7 @@ var SvgImagePlaceholder = function SvgImagePlaceholder(props) {
 };
 var ImagePlaceholder = SvgImagePlaceholder;
 
-const type$7 = 'image';
+const type$8 = 'image';
 function Image(props) {
   const {
     field
@@ -3545,7 +4579,7 @@ function Image(props) {
     formId
   } = hooks.useContext(FormContext$1);
   return jsxRuntime.jsx("div", {
-    class: formFieldClasses(type$7),
+    class: formFieldClasses(type$8),
     children: jsxRuntime.jsxs("div", {
       class: "fjs-image-container",
       children: [safeSource && jsxRuntime.jsx("img", {
@@ -3563,7 +4597,7 @@ function Image(props) {
   });
 }
 Image.config = {
-  type: type$7,
+  type: type$8,
   keyed: false,
   label: 'Image view',
   group: 'presentation',
@@ -3590,14 +4624,14 @@ function TemplatedInputAdorner(props) {
   });
 }
 
-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 _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__namespace.createElement("svg", _extends$g({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$h({
     xmlns: "http://www.w3.org/2000/svg",
     width: 8,
     height: 8
-  }, props), _path$e || (_path$e = /*#__PURE__*/React__namespace.createElement("path", {
+  }, props), _path$f || (_path$f = /*#__PURE__*/React__namespace.createElement("path", {
     fill: "currentColor",
     fillRule: "evenodd",
     stroke: "currentColor",
@@ -3608,14 +4642,14 @@ var SvgAngelDown = function SvgAngelDown(props) {
 };
 var AngelDownIcon = SvgAngelDown;
 
-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 _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 SvgAngelUp = function SvgAngelUp(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$f({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$g({
     xmlns: "http://www.w3.org/2000/svg",
     width: 8,
     height: 8
-  }, props), _path$d || (_path$d = /*#__PURE__*/React__namespace.createElement("path", {
+  }, props), _path$e || (_path$e = /*#__PURE__*/React__namespace.createElement("path", {
     fill: "currentColor",
     fillRule: "evenodd",
     stroke: "currentColor",
@@ -3626,11 +4660,12 @@ var SvgAngelUp = function SvgAngelUp(props) {
 };
 var AngelUpIcon = SvgAngelUp;
 
-const type$6 = 'number';
+const type$7 = 'number';
 function Numberfield(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     value,
     readonly,
@@ -3763,7 +4798,7 @@ function Numberfield(props) {
   } = hooks.useContext(FormContext$1);
   const errorMessageId = errors.length === 0 ? undefined : `${prefixId(id, formId)}-error-message`;
   return jsxRuntime.jsxs("div", {
-    class: formFieldClasses(type$6, {
+    class: formFieldClasses(type$7, {
       errors,
       disabled,
       readonly
@@ -3791,7 +4826,8 @@ function Numberfield(props) {
           readOnly: readonly,
           id: prefixId(id, formId),
           onKeyDown: onKeyDown,
-          onKeyPress: onKeyPress
+          onKeyPress: onKeyPress,
+          onBlur: onBlur
 
           // @ts-ignore
           ,
@@ -3834,7 +4870,7 @@ function Numberfield(props) {
   });
 }
 Numberfield.config = {
-  type: type$6,
+  type: type$7,
   keyed: true,
   label: 'Number',
   group: 'basic-input',
@@ -3857,11 +4893,12 @@ Numberfield.config = {
   })
 };
 
-const type$5 = 'radio';
+const type$6 = 'radio';
 function Radio(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value
@@ -3872,6 +4909,7 @@ function Radio(props) {
     label,
     validate = {}
   } = field;
+  const outerDivRef = hooks.useRef();
   const {
     required
   } = validate;
@@ -3881,6 +4919,12 @@ function Radio(props) {
       value: v
     });
   };
+  const onRadioBlur = e => {
+    if (outerDivRef.current.contains(e.relatedTarget)) {
+      return;
+    }
+    onBlur();
+  };
   const {
     state: loadState,
     values: options
@@ -3890,11 +4934,12 @@ function Radio(props) {
   } = hooks.useContext(FormContext$1);
   const errorMessageId = errors.length === 0 ? undefined : `${prefixId(id, formId)}-error-message`;
   return jsxRuntime.jsxs("div", {
-    class: formFieldClasses(type$5, {
+    class: formFieldClasses(type$6, {
       errors,
       disabled,
       readonly
     }),
+    ref: outerDivRef,
     children: [jsxRuntime.jsx(Label, {
       label: label,
       required: required
@@ -3914,6 +4959,7 @@ function Radio(props) {
           id: prefixId(`${id}-${index}`, formId),
           type: "radio",
           onClick: () => onChange(option.value),
+          onBlur: onRadioBlur,
           "aria-describedby": errorMessageId
         })
       }, `${id}-${index}`);
@@ -3926,37 +4972,23 @@ function Radio(props) {
   });
 }
 Radio.config = {
-  type: type$5,
+  type: type$6,
   keyed: true,
   label: 'Radio',
   group: 'selection',
   emptyValue: null,
   sanitizeValue: sanitizeSingleSelectValue,
-  create: (options = {}) => {
-    const defaults = {};
-
-    // provide default values if valuesKey isn't set
-    if (!options.valuesKey) {
-      defaults.values = [{
-        label: 'Value',
-        value: 'value'
-      }];
-    }
-    return {
-      ...defaults,
-      ...options
-    };
-  }
+  create: createEmptyOptions
 };
 
-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 _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__namespace.createElement("svg", _extends$e({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$f({
     xmlns: "http://www.w3.org/2000/svg",
     width: 8,
     height: 8
-  }, props), _path$c || (_path$c = /*#__PURE__*/React__namespace.createElement("path", {
+  }, props), _path$d || (_path$d = /*#__PURE__*/React__namespace.createElement("path", {
     fill: "currentColor",
     fillRule: "evenodd",
     stroke: "currentColor",
@@ -3972,6 +5004,7 @@ function SearchableSelect(props) {
     id,
     disabled,
     errors,
+    onBlur,
     field,
     readonly,
     value
@@ -4091,6 +5124,7 @@ function SearchableSelect(props) {
         onBlur: () => {
           setIsDropdownExpanded(false);
           setFilter(valueLabel);
+          onBlur();
         },
         "aria-describedby": props['aria-describedby']
       }), displayState.displayCross && jsxRuntime.jsxs("span", {
@@ -4125,6 +5159,7 @@ function SimpleSelect(props) {
     id,
     disabled,
     errors,
+    onBlur,
     field,
     readonly,
     value
@@ -4179,7 +5214,10 @@ function SimpleSelect(props) {
         'hasErrors': errors.length
       }),
       onFocus: () => setIsDropdownExpanded(true),
-      onBlur: () => setIsDropdownExpanded(false),
+      onBlur: () => {
+        setIsDropdownExpanded(false);
+        onBlur();
+      },
       onMouseDown: onMouseDown,
       children: [jsxRuntime.jsx("div", {
         class: classNames('fjs-select-display', {
@@ -4221,11 +5259,12 @@ function SimpleSelect(props) {
   });
 }
 
-const type$4 = 'select';
+const type$5 = 'select';
 function Select(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     onChange,
     readonly,
@@ -4249,14 +5288,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 jsxRuntime.jsxs("div", {
-    class: formFieldClasses(type$4, {
+    class: formFieldClasses(type$5, {
       errors,
       disabled,
       readonly
@@ -4284,27 +5324,39 @@ function Select(props) {
   });
 }
 Select.config = {
-  type: type$4,
+  type: type$5,
   keyed: true,
   label: 'Select',
   group: 'selection',
   emptyValue: null,
   sanitizeValue: sanitizeSingleSelectValue,
-  create: (options = {}) => {
-    const defaults = {};
+  create: createEmptyOptions
+};
 
-    // provide default values if valuesKey isn't set
-    if (!options.valuesKey) {
-      defaults.values = [{
-        label: 'Value',
-        value: 'value'
-      }];
+const type$4 = 'spacer';
+function Spacer(props) {
+  const {
+    field
+  } = props;
+  const {
+    height = 60
+  } = field;
+  return jsxRuntime.jsx("div", {
+    class: formFieldClasses(type$4),
+    style: {
+      height: height
     }
-    return {
-      ...defaults,
-      ...options
-    };
-  }
+  });
+}
+Spacer.config = {
+  type: type$4,
+  keyed: false,
+  label: 'Spacer',
+  group: 'presentation',
+  create: (options = {}) => ({
+    height: 60,
+    ...options
+  })
 };
 
 const type$3 = 'taglist';
@@ -4312,6 +5364,7 @@ function Taglist(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value: values = []
@@ -4404,9 +5457,10 @@ function Taglist(props) {
         break;
     }
   };
-  const onBlur = () => {
+  const onComponentBlur = () => {
     setIsDropdownExpanded(false);
     setFilter('');
+    onBlur();
   };
   const onTagRemoveClick = (event, value) => {
     const {
@@ -4477,9 +5531,7 @@ function Taglist(props) {
         onKeyDown: onInputKeyDown,
         onMouseDown: () => setIsEscapeClose(false),
         onFocus: () => !readonly && setIsDropdownExpanded(true),
-        onBlur: () => {
-          !readonly && onBlur();
-        },
+        onBlur: () => !readonly && onComponentBlur(),
         "aria-describedby": errorMessageId
       })]
     }), jsxRuntime.jsx("div", {
@@ -4506,21 +5558,7 @@ Taglist.config = {
   group: 'selection',
   emptyValue: [],
   sanitizeValue: sanitizeMultiSelectValue,
-  create: (options = {}) => {
-    const defaults = {};
-
-    // provide default values if valuesKey isn't set
-    if (!options.valuesKey) {
-      defaults.values = [{
-        label: 'Value',
-        value: 'value'
-      }];
-    }
-    return {
-      ...defaults,
-      ...options
-    };
-  }
+  create: createEmptyOptions
 };
 
 const type$2 = 'text';
@@ -4612,6 +5650,7 @@ function Textfield(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value = ''
@@ -4663,6 +5702,7 @@ function Textfield(props) {
         readOnly: readonly,
         id: prefixId(id, formId),
         onInput: onChange,
+        onBlur: onBlur,
         type: "text",
         value: value,
         "aria-describedby": errorMessageId
@@ -4704,6 +5744,7 @@ function Textarea(props) {
   const {
     disabled,
     errors = [],
+    onBlur,
     field,
     readonly,
     value = ''
@@ -4726,22 +5767,12 @@ function Textarea(props) {
       value: target.value
     });
   };
-  const autoSizeTextarea = hooks.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';
-  }, []);
+  hooks.useLayoutEffect(() => {
+    autoSizeTextarea(textareaRef.current);
+  }, [value]);
   hooks.useEffect(() => {
     autoSizeTextarea(textareaRef.current);
-  }, [autoSizeTextarea, value]);
+  }, []);
   const {
     formId
   } = hooks.useContext(FormContext$1);
@@ -4762,6 +5793,7 @@ function Textarea(props) {
       readonly: readonly,
       id: prefixId(id, formId),
       onInput: onInput,
+      onBlur: onBlur,
       value: value,
       ref: textareaRef,
       "aria-describedby": errorMessageId
@@ -4786,40 +5818,58 @@ 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$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 _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__namespace.createElement("svg", _extends$d({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$e({
     xmlns: "http://www.w3.org/2000/svg",
     width: 54,
     height: 54,
     fill: "currentcolor"
-  }, props), _path$b || (_path$b = /*#__PURE__*/React__namespace.createElement("path", {
+  }, props), _path$c || (_path$c = /*#__PURE__*/React__namespace.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$a;
-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 _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 SvgCheckbox = function SvgCheckbox(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$c({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$d({
     xmlns: "http://www.w3.org/2000/svg",
     width: 54,
     height: 54,
     fill: "currentcolor"
-  }, props), _path$a || (_path$a = /*#__PURE__*/React__namespace.createElement("path", {
+  }, props), _path$b || (_path$b = /*#__PURE__*/React__namespace.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$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); }
+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 SvgChecklist = function SvgChecklist(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$b({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$c({
     xmlns: "http://www.w3.org/2000/svg",
     xmlnsXlink: "http://www.w3.org/1999/xlink",
     width: 54,
@@ -4853,18 +5903,18 @@ var SvgChecklist = function SvgChecklist(props) {
 };
 var ChecklistIcon = SvgChecklist;
 
-var _path$9, _path2$2, _path3;
-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 _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 SvgDatetime = function SvgDatetime(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$a({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$b({
     xmlns: "http://www.w3.org/2000/svg",
     width: 54,
     height: 54,
     fill: "currentcolor"
-  }, props), _path$9 || (_path$9 = /*#__PURE__*/React__namespace.createElement("path", {
+  }, props), _path$a || (_path$a = /*#__PURE__*/React__namespace.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$2 || (_path2$2 = /*#__PURE__*/React__namespace.createElement("path", {
+  })), _path2$3 || (_path2$3 = /*#__PURE__*/React__namespace.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__namespace.createElement("path", {
     fillRule: "evenodd",
@@ -4873,27 +5923,27 @@ var SvgDatetime = function SvgDatetime(props) {
 };
 var DatetimeIcon = SvgDatetime;
 
-var _path$8, _path2$1;
-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 _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 SvgTaglist = function SvgTaglist(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$9({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$a({
     xmlns: "http://www.w3.org/2000/svg",
     width: 54,
     height: 54,
     fill: "currentcolor"
-  }, props), _path$8 || (_path$8 = /*#__PURE__*/React__namespace.createElement("path", {
+  }, props), _path$9 || (_path$9 = /*#__PURE__*/React__namespace.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$1 || (_path2$1 = /*#__PURE__*/React__namespace.createElement("path", {
+  })), _path2$2 || (_path2$2 = /*#__PURE__*/React__namespace.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$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); }
+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 SvgForm = function SvgForm(props) {
-  return /*#__PURE__*/React__namespace.createElement("svg", _extends$8({
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$9({
     xmlns: "http://www.w3.org/2000/svg",
     width: 54,
     height: 54
@@ -4919,63 +5969,87 @@ var SvgForm = function SvgForm(props) {
 };
 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 SvgGroup = function SvgGroup(props) {
+  return /*#__PURE__*/React__namespace.createElement("svg", _extends$8({
+    xmlns: "http://www.w3.org/2000/svg",
+    width: 54,
+    height: 54,
+    fill: "currentcolor"
+  }, props), _path$8 || (_path$8 = /*#__PURE__*/React__namespace.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 GroupIcon = 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 SvgGroup = function SvgGroup(props) {
+var SvgNumber = function SvgNumber(props) {
   return /*#__PURE__*/React__namespace.createElement("svg", _extends$7({
     xmlns: "http://www.w3.org/2000/svg",
     width: 54,
-    height: 54
+    height: 54,
+    fill: "currentcolor"
   }, props), _path$7 || (_path$7 = /*#__PURE__*/React__namespace.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"
+    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 ColumnsIcon = SvgGroup;
+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 SvgNumber = function SvgNumber(props) {
+var SvgRadio = function SvgRadio(props) {
   return /*#__PURE__*/React__namespace.createElement("svg", _extends$6({
     xmlns: "http://www.w3.org/2000/svg",
     width: 54,
     height: 54,
     fill: "currentcolor"
   }, props), _path$6 || (_path$6 = /*#__PURE__*/React__namespace.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"
+    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 NumberIcon = SvgNumber;
+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 SvgRadio = function SvgRadio(props) {
+var SvgSelect = function SvgSelect(props) {
   return /*#__PURE__*/React__namespace.createElement("svg", _extends$5({
     xmlns: "http://www.w3.org/2000/svg",
     width: 54,
     height: 54,
     fill: "currentcolor"
   }, props), _path$5 || (_path$5 = /*#__PURE__*/React__namespace.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"
+    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 RadioIcon = SvgRadio;
+var SelectIcon = SvgSelect;
 
-var _path$4;
+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 SvgSelect = function SvgSelect(props) {
+var SvgSpacer = function SvgSpacer(props) {
   return /*#__PURE__*/React__namespace.createElement("svg", _extends$4({
     xmlns: "http://www.w3.org/2000/svg",
     width: 54,
     height: 54,
     fill: "currentcolor"
   }, props), _path$4 || (_path$4 = /*#__PURE__*/React__namespace.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"
+    stroke: "currentcolor",
+    strokeLinecap: "square",
+    strokeWidth: 2,
+    d: "M9 23h36M9 31h36"
+  })), _path2$1 || (_path2$1 = /*#__PURE__*/React__namespace.createElement("path", {
+    stroke: "currentcolor",
+    strokeLinecap: "round",
+    strokeLinejoin: "round",
+    strokeWidth: 2,
+    d: "m23 17 4-4 4 4M31 37l-4 4-4-4"
   })));
 };
-var SelectIcon = SvgSelect;
+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); }
@@ -5046,12 +6120,14 @@ const iconsByType = type => {
     button: ButtonIcon,
     checkbox: CheckboxIcon,
     checklist: ChecklistIcon,
-    columns: ColumnsIcon,
+    columns: GroupIcon,
     datetime: DatetimeIcon,
+    group: GroupIcon,
     image: ImageIcon,
     number: NumberIcon,
     radio: RadioIcon,
     select: SelectIcon,
+    spacer: SpacerIcon,
     taglist: TaglistIcon,
     text: TextIcon,
     textfield: TextfieldIcon,
@@ -5060,7 +6136,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, FormComponent$1, Group, Image, Numberfield, Datetime, Radio, Select, Spacer, Taglist, Text, Textfield, Textarea];
 
 class FormFields {
   constructor() {
@@ -5136,9 +6212,12 @@ var renderModule = {
 };
 
 var core = {
-  __depends__: [importModule, renderModule],
+  __depends__: [renderModule],
   eventBus: ['type', EventBus],
+  importer: ['type', Importer],
+  fieldFactory: ['type', FieldFactory],
   formFieldRegistry: ['type', FormFieldRegistry],
+  pathRegistry: ['type', PathRegistry],
   formLayouter: ['type', FormLayouter],
   validator: ['type', Validator]
 };
@@ -5253,9 +6332,9 @@ class Form {
         this.clear();
         const {
           schema: importedSchema,
-          data: initializedData,
           warnings
-        } = this.get('importer').importSchema(schema, data);
+        } = this.get('importer').importSchema(schema);
+        const initializedData = this._initializeFieldData(clone(data));
         this._setState({
           data: initializedData,
           errors: {},
@@ -5313,21 +6392,21 @@ class Form {
    */
   validate() {
     const formFieldRegistry = this.get('formFieldRegistry'),
+      pathRegistry = this.get('pathRegistry'),
       validator = this.get('validator');
     const {
       data
     } = this._getState();
     const errors = formFieldRegistry.getAll().reduce((errors, field) => {
       const {
-        disabled,
-        _path
+        disabled
       } = field;
       if (disabled) {
         return errors;
       }
-      const value = minDash.get(data, _path);
+      const value = minDash.get(data, pathRegistry.getValuePath(field));
       const fieldErrors = validator.validateField(field, value);
-      return minDash.set(errors, [pathStringify(_path)], fieldErrors.length ? fieldErrors : undefined);
+      return minDash.set(errors, [field.id], fieldErrors.length ? fieldErrors : undefined);
     }, /** @type {Errors} */{});
     this._setState({
       errors
@@ -5433,16 +6512,14 @@ class Form {
       value
     } = update;
     const {
-      _path
-    } = field;
-    let {
       data,
       errors
     } = this._getState();
-    const validator = this.get('validator');
+    const validator = this.get('validator'),
+      pathRegistry = this.get('pathRegistry');
     const fieldErrors = validator.validateField(field, value);
-    minDash.set(data, _path, value);
-    minDash.set(errors, [pathStringify(_path)], fieldErrors.length ? fieldErrors : undefined);
+    minDash.set(data, pathRegistry.getValuePath(field), value);
+    minDash.set(errors, [field.id], fieldErrors.length ? fieldErrors : undefined);
     this._setState({
       data: clone(data),
       errors: clone(errors)
@@ -5471,7 +6548,7 @@ class Form {
   * @internal
   */
   _getModules() {
-    return [ExpressionLanguageModule, MarkdownModule];
+    return [ExpressionLanguageModule, MarkdownModule, ViewerCommandsModule];
   }
 
   /**
@@ -5485,23 +6562,26 @@ class Form {
    * @internal
    */
   _getSubmitData() {
-    const formFieldRegistry = this.get('formFieldRegistry');
+    const formFieldRegistry = this.get('formFieldRegistry'),
+      pathRegistry = this.get('pathRegistry'),
+      formFields = this.get('formFields');
     const formData = this._getState().data;
     const submitData = formFieldRegistry.getAll().reduce((previous, field) => {
       const {
         disabled,
-        _path
+        type
       } = field;
+      const {
+        config: fieldConfig
+      } = formFields.get(type);
 
-      // do not submit disabled form fields
-      if (disabled || !_path) {
+      // do not submit disabled form fields or routing fields
+      if (disabled || !fieldConfig.keyed) {
         return previous;
       }
-      const value = minDash.get(formData, _path);
-      return {
-        ...previous,
-        [_path[0]]: value
-      };
+      const valuePath = pathRegistry.getValuePath(field);
+      const value = minDash.get(formData, valuePath);
+      return minDash.set(previous, valuePath, value);
     }, {});
     const filteredSubmitData = this._applyConditions(submitData, formData);
     return filteredSubmitData;
@@ -5514,9 +6594,46 @@ class Form {
     const conditionChecker = this.get('conditionChecker');
     return conditionChecker.applyConditions(toFilter, data);
   }
+
+  /**
+   * @internal
+   */
+  _initializeFieldData(data) {
+    const formFieldRegistry = this.get('formFieldRegistry'),
+      formFields = this.get('formFields'),
+      pathRegistry = this.get('pathRegistry');
+    return formFieldRegistry.getAll().reduce((initializedData, formField) => {
+      const {
+        defaultValue,
+        type
+      } = formField;
+
+      // try to get value from data
+      // if unavailable - try to get default value from form field
+      // if unavailable - get empty value from form field
+
+      const valuePath = pathRegistry.getValuePath(formField);
+      if (valuePath) {
+        const {
+          config: fieldConfig
+        } = formFields.get(type);
+        let valueData = minDash.get(data, valuePath);
+        if (!minDash.isUndefined(valueData) && fieldConfig.sanitizeValue) {
+          valueData = fieldConfig.sanitizeValue({
+            formField,
+            data,
+            value: valueData
+          });
+        }
+        const initializedFieldValue = !minDash.isUndefined(valueData) ? valueData : !minDash.isUndefined(defaultValue) ? defaultValue : fieldConfig.emptyValue;
+        return minDash.set(initializedData, valuePath, initializedFieldValue);
+      }
+      return initializedData;
+    }, data);
+  }
 }
 
-const schemaVersion = 9;
+const schemaVersion = 11;
 
 /**
  * @typedef { import('./types').CreateFormOptions } CreateFormOptions
@@ -5551,10 +6668,11 @@ exports.DATETIME_SUBTYPE_PATH = DATETIME_SUBTYPE_PATH;
 exports.DATE_DISALLOW_PAST_PATH = DATE_DISALLOW_PAST_PATH;
 exports.DATE_LABEL_PATH = DATE_LABEL_PATH;
 exports.Datetime = Datetime;
-exports.Default = Default;
+exports.Default = FormComponent$1;
 exports.ExpressionLanguageModule = ExpressionLanguageModule;
 exports.FeelExpressionLanguage = FeelExpressionLanguage;
 exports.FeelersTemplating = FeelersTemplating;
+exports.FieldFactory = FieldFactory;
 exports.Form = Form;
 exports.FormComponent = FormComponent;
 exports.FormContext = FormContext$1;
@@ -5562,13 +6680,17 @@ exports.FormFieldRegistry = FormFieldRegistry;
 exports.FormFields = FormFields;
 exports.FormLayouter = FormLayouter;
 exports.FormRenderContext = FormRenderContext$1;
+exports.Group = Group;
 exports.Image = Image;
+exports.Importer = Importer;
 exports.MINUTES_IN_DAY = MINUTES_IN_DAY;
 exports.MarkdownModule = MarkdownModule;
 exports.MarkdownRenderer = MarkdownRenderer;
 exports.Numberfield = Numberfield;
+exports.PathRegistry = PathRegistry;
 exports.Radio = Radio;
 exports.Select = Select;
+exports.Spacer = Spacer;
 exports.TIME_INTERVAL_PATH = TIME_INTERVAL_PATH;
 exports.TIME_LABEL_PATH = TIME_LABEL_PATH;
 exports.TIME_SERIALISINGFORMAT_LABELS = TIME_SERIALISINGFORMAT_LABELS;
@@ -5584,11 +6706,12 @@ exports.VALUES_SOURCES_DEFAULTS = VALUES_SOURCES_DEFAULTS;
 exports.VALUES_SOURCES_LABELS = VALUES_SOURCES_LABELS;
 exports.VALUES_SOURCES_PATHS = VALUES_SOURCES_PATHS;
 exports.VALUES_SOURCE_DEFAULT = VALUES_SOURCE_DEFAULT;
+exports.ViewerCommands = ViewerCommands;
+exports.ViewerCommandsModule = ViewerCommandsModule;
 exports.clone = clone;
 exports.createForm = createForm;
 exports.createFormContainer = createFormContainer;
 exports.createInjector = createInjector;
-exports.findErrors = findErrors;
 exports.formFields = formFields;
 exports.generateIdForType = generateIdForType;
 exports.generateIndexForType = generateIndexForType;
@@ -5597,7 +6720,7 @@ exports.getValuesSource = getValuesSource;
 exports.iconsByType = iconsByType;
 exports.isRequired = isRequired;
 exports.pathParse = pathParse;
-exports.pathStringify = pathStringify;
 exports.pathsEqual = pathsEqual;
+exports.runRecursively = runRecursively;
 exports.schemaVersion = schemaVersion;
 //# sourceMappingURL=index.cjs.map