@bpmn-io/form-js-viewer 1.1.0 → 1.3.0

package/dist/index.cjs

@@ -407,14 +407,230 @@ class FeelersTemplating {
 }
 FeelersTemplating.$inject = [];
 
+// 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;
   }
 
@@ -425,19 +641,27 @@ class ConditionChecker {
    * @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;
   }
 
@@ -482,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'],
@@ -967,239 +1185,42 @@ CommandStack.prototype._popAction = function () {
     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]
-};
-
-// 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, options = {}) {
-  const {
-    expressionLanguage = new FeelExpressionLanguage(null),
-    templating = new FeelersTemplating(),
-    inputs = true,
-    outputs = true
-  } = options;
-  if (!schema.components) {
-    return [];
-  }
-  const variables = schema.components.reduce((variables, component) => {
-    const {
-      key,
-      valuesKey,
-      type
-    } = component;
-    if (['button'].includes(type)) {
-      return variables;
-    }
-
-    // collect bi-directional variables
-    if (inputs || outputs) {
-      if (key) {
-        variables = [...variables, key];
-      }
-    }
-
-    // collect input-only variables
-    if (inputs) {
-      if (valuesKey) {
-        variables = [...variables, valuesKey];
-      }
-      EXPRESSION_PROPERTIES.forEach(prop => {
-        const property = 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);
-  }, []);
+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;
+};
 
-  // remove duplicates
-  return Array.from(new Set(variables));
-}
+/**
+ * @type { import('didi').ModuleDeclaration }
+ */
+var commandModule = {
+  commandStack: ['type', CommandStack]
+};
 
 class UpdateFieldValidationHandler {
   constructor(form, validator) {
@@ -1211,15 +1232,12 @@ class UpdateFieldValidationHandler {
       field,
       value
     } = context;
-    const {
-      _path
-    } = field;
     const {
       errors
     } = this._form._getState();
     context.oldErrors = clone(errors);
     const fieldErrors = this._validator.validateField(field, value);
-    const updatedErrors = minDash.set(errors, [pathStringify(_path)], fieldErrors.length ? fieldErrors : undefined);
+    const updatedErrors = minDash.set(errors, [field.id], fieldErrors.length ? fieldErrors : undefined);
     this._form._setState({
       errors: updatedErrors
     });
@@ -1902,54 +1920,397 @@ 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) {
+
+  /**
+   * 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;
+    }
+  }
+  _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 {
-      id
-    } = formField;
-    if (this._formFields[id]) {
-      throw new Error(`form field with ID ${id} already exists`);
+      components
+    } = fieldAttrs;
+    let parent, path;
+    if (parentId) {
+      parent = this._formFieldRegistry.get(parentId);
     }
-    this._eventBus.fire('formField.add', {
-      formField
+
+    // 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);
   }
-  getAll() {
-    return Object.values(this._formFields);
+  _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);
   }
-  forEach(callback) {
-    this.getAll().forEach(formField => callback(formField));
+}
+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 = [];
+  }
+  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
@@ -2041,7 +2402,7 @@ class FormLayouter {
       type,
       components
     } = formField;
-    if (type !== 'default' || !components) {
+    if (type !== 'default' && type !== 'group' || !components) {
       return;
     }
 
@@ -2096,147 +2457,52 @@ function allRows(formRows) {
   return minDash.flatten(formRows.map(c => c.rows));
 }
 
-class Importer {
-  /**
-   * @constructor
-   * @param { import('../core').FormFieldRegistry } formFieldRegistry
-   * @param { import('../render/FormFields').default } formFields
-   * @param { import('../core').FormLayouter } formLayouter
-   */
-  constructor(formFieldRegistry, formFields, formLayouter) {
-    this._formFieldRegistry = formFieldRegistry;
-    this._formFields = formFields;
-    this._formLayouter = formLayouter;
-  }
-
-  /**
-   * Import schema adding `id`, `_parent` and `_path`
-   * information to each field and adding it to the
-   * form field registry.
-   *
-   * @param {any} schema
-   * @param {any} [data]
-   *
-   * @return { { warnings: Array<any>, schema: any, data: any } }
-   */
-  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;
-    }
+class FormFieldRegistry {
+  constructor(eventBus) {
+    this._eventBus = eventBus;
+    this._formFields = {};
+    eventBus.on('form.clear', () => this.clear());
+    this._ids = new Ids([32, 36, 1]);
   }
-
-  /**
-   * @param {any} formField
-   * @param {string} [parentId]
-   *
-   * @return {any} importedField
-   */
-  importFormField(formField, parentId) {
+  add(formField) {
     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`);
-    }
-    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);
-
-      // 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);
-    }
-
-    // set form field ID
-    formField.id = id;
-    this._formFieldRegistry.add(formField);
-    if (components) {
-      this.importFormFields(components, id);
+      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 = [],
@@ -2291,7 +2557,7 @@ function Button(props) {
 }
 Button.config = {
   type: type$c,
-  keyed: true,
+  keyed: false,
   label: 'Button',
   group: 'action',
   create: (options = {}) => ({
@@ -2301,6 +2567,9 @@ Button.config = {
 };
 
 const FormRenderContext = preact.createContext({
+  EmptyRoot: props => {
+    return null;
+  },
   Empty: props => {
     return null;
   },
@@ -2330,6 +2599,10 @@ 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;
@@ -2451,6 +2724,37 @@ function useReadonly(formField, properties = {}) {
   return readonly || false;
 }
 
+function usePrevious(value, defaultValue, dependencies) {
+  const ref = hooks.useRef(defaultValue);
+  hooks.useEffect(() => ref.current = value, dependencies);
+  return ref.current;
+}
+
+/**
+ * A custom hook to manage state changes with deep comparison.
+ *
+ * @param {any} value - The current value to manage.
+ * @param {any} defaultValue - The initial default value for the state.
+ * @returns {any} - Returns the current state.
+ */
+function useDeepCompareState(value, defaultValue) {
+  const [state, setState] = hooks.useState(defaultValue);
+  const previous = usePrevious(value, defaultValue, [value]);
+  const changed = !compare(previous, value);
+  hooks.useEffect(() => {
+    if (changed) {
+      setState(value);
+    }
+  }, [changed, value]);
+  return state;
+}
+
+// helpers //////////////////////////
+
+function compare(a, b) {
+  return JSON.stringify(a) === JSON.stringify(b);
+}
+
 /**
  * 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
@@ -2671,6 +2975,21 @@ function _isReadableType(value) {
 function _isValueSomething(value) {
   return value || value === 0 || value === false;
 }
+function createEmptyOptions(options = {}) {
+  const defaults = {};
+
+  // 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 }
@@ -2705,11 +3024,8 @@ function useValuesAsync (field) {
     state: LOAD_STATES.LOADING
   });
   const initialData = useService('form')._getState().initialData;
-  const evaluatedValues = hooks.useMemo(() => {
-    if (valuesExpression) {
-      return useExpressionEvaluation(valuesExpression);
-    }
-  }, [valuesExpression]);
+  const expressionEvaluation = useExpressionEvaluation(valuesExpression);
+  const evaluatedValues = useDeepCompareState(expressionEvaluation || [], []);
   hooks.useEffect(() => {
     let values = [];
 
@@ -2725,8 +3041,10 @@ function useValuesAsync (field) {
       values = Array.isArray(staticValues) ? staticValues : [];
 
       // expression
-    } else if (evaluatedValues && Array.isArray(evaluatedValues)) {
-      values = evaluatedValues;
+    } else if (valuesExpression) {
+      if (evaluatedValues && Array.isArray(evaluatedValues)) {
+        values = evaluatedValues;
+      }
     } else {
       setValuesGetter(buildErrorState('No values source defined in the form definition'));
       return;
@@ -2735,7 +3053,7 @@ function useValuesAsync (field) {
     // normalize data to support primitives and partially defined objects
     values = normalizeValuesData(values);
     setValuesGetter(buildLoadedState(values));
-  }, [valuesKey, staticValues, initialData]);
+  }, [valuesKey, staticValues, initialData, valuesExpression, evaluatedValues]);
   return valuesGetter;
 }
 const buildErrorState = error => ({
@@ -3047,21 +3365,7 @@ Checklist.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 noop$1 = () => false;
@@ -3072,6 +3376,7 @@ function FormField(props) {
   } = props;
   const formFields = useService('formFields'),
     viewerCommands = useService('viewerCommands', false),
+    pathRegistry = useService('pathRegistry'),
     form = useService('form');
   const {
     initialData,
@@ -3088,10 +3393,10 @@ function FormField(props) {
   if (!FormFieldComponent) {
     throw new Error(`cannot render field <${field.type}>`);
   }
-  const initialValue = hooks.useMemo(() => minDash.get(initialData, field._path), [initialData, field._path]);
-  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);
@@ -3118,7 +3423,7 @@ 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,
@@ -3128,14 +3433,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,
@@ -3172,7 +3477,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,
@@ -3201,6 +3519,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,
@@ -3275,7 +3661,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)
@@ -3367,7 +3753,7 @@ function Datepicker(props) {
           class: "fjs-input",
           disabled: disabled,
           readOnly: readonly,
-          placeholder: "mm/dd/yyyy",
+          placeholder: getLocaleReadableDateFormat(),
           autoComplete: "off",
           onFocus: onInputFocus,
           onKeyDown: onInputKeyDown,
@@ -3452,7 +3838,8 @@ function DropdownList(props) {
   hooks.useEffect(() => {
     const individualEntries = dropdownContainer.current.children;
     if (individualEntries.length && !mouseControl) {
-      individualEntries[focusedValueIndex].scrollIntoView({
+      const focusedEntry = individualEntries[focusedValueIndex];
+      focusedEntry && focusedEntry.scrollIntoView({
         block: 'nearest',
         inline: 'nearest'
       });
@@ -3988,6 +4375,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'];
@@ -4576,21 +5009,7 @@ Radio.config = {
   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$d;
@@ -4942,21 +5361,7 @@ Select.config = {
   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
 };
 
 const type$4 = 'spacer';
@@ -5184,21 +5589,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';
@@ -5615,13 +6006,14 @@ var SvgGroup = function SvgGroup(props) {
   return /*#__PURE__*/React__namespace.createElement("svg", _extends$8({
     xmlns: "http://www.w3.org/2000/svg",
     width: 54,
-    height: 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 ColumnsIcon = SvgGroup;
+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); }
@@ -5674,14 +6066,14 @@ var SvgSpacer = function SvgSpacer(props) {
     xmlns: "http://www.w3.org/2000/svg",
     width: 54,
     height: 54,
-    fill: "none"
+    fill: "currentcolor"
   }, props), _path$4 || (_path$4 = /*#__PURE__*/React__namespace.createElement("path", {
-    stroke: "#000",
+    stroke: "currentcolor",
     strokeLinecap: "square",
     strokeWidth: 2,
     d: "M9 23h36M9 31h36"
   })), _path2$1 || (_path2$1 = /*#__PURE__*/React__namespace.createElement("path", {
-    stroke: "#000",
+    stroke: "currentcolor",
     strokeLinecap: "round",
     strokeLinejoin: "round",
     strokeWidth: 2,
@@ -5759,8 +6151,9 @@ const iconsByType = type => {
     button: ButtonIcon,
     checkbox: CheckboxIcon,
     checklist: ChecklistIcon,
-    columns: ColumnsIcon,
+    columns: GroupIcon,
     datetime: DatetimeIcon,
+    group: GroupIcon,
     image: ImageIcon,
     number: NumberIcon,
     radio: RadioIcon,
@@ -5774,7 +6167,7 @@ const iconsByType = type => {
   }[type];
 };
 
-const formFields = [Button, Checkbox, Checklist, Default, Image, Numberfield, Datetime, Radio, Select, Spacer, 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() {
@@ -5850,62 +6243,65 @@ 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]
 };
 
-/**
- * @typedef { import('./types').Injector } Injector
- * @typedef { import('./types').Data } Data
- * @typedef { import('./types').Errors } Errors
- * @typedef { import('./types').Schema } Schema
- * @typedef { import('./types').FormProperties } FormProperties
- * @typedef { import('./types').FormProperty } FormProperty
- * @typedef { import('./types').FormEvent } FormEvent
- * @typedef { import('./types').FormOptions } FormOptions
- *
- * @typedef { {
- *   data: Data,
- *   initialData: Data,
- *   errors: Errors,
- *   properties: FormProperties,
- *   schema: Schema
- * } } State
- *
- * @typedef { (type:FormEvent, priority:number, handler:Function) => void } OnEventWithPriority
- * @typedef { (type:FormEvent, handler:Function) => void } OnEventWithOutPriority
- * @typedef { OnEventWithPriority & OnEventWithOutPriority } OnEventType
+/**
+ * @typedef { import('./types').Injector } Injector
+ * @typedef { import('./types').Data } Data
+ * @typedef { import('./types').Errors } Errors
+ * @typedef { import('./types').Schema } Schema
+ * @typedef { import('./types').FormProperties } FormProperties
+ * @typedef { import('./types').FormProperty } FormProperty
+ * @typedef { import('./types').FormEvent } FormEvent
+ * @typedef { import('./types').FormOptions } FormOptions
+ *
+ * @typedef { {
+ *   data: Data,
+ *   initialData: Data,
+ *   errors: Errors,
+ *   properties: FormProperties,
+ *   schema: Schema
+ * } } State
+ *
+ * @typedef { (type:FormEvent, priority:number, handler:Function) => void } OnEventWithPriority
+ * @typedef { (type:FormEvent, handler:Function) => void } OnEventWithOutPriority
+ * @typedef { OnEventWithPriority & OnEventWithOutPriority } OnEventType
  */
 
 const ids = new Ids([32, 36, 1]);
 
-/**
- * The form.
+/**
+ * The form.
  */
 class Form {
-  /**
-   * @constructor
-   * @param {FormOptions} options
+  /**
+   * @constructor
+   * @param {FormOptions} options
    */
   constructor(options = {}) {
-    /**
-     * @public
-     * @type {OnEventType}
+    /**
+     * @public
+     * @type {OnEventType}
      */
     this.on = this._onEvent;
 
-    /**
-     * @public
-     * @type {String}
+    /**
+     * @public
+     * @type {String}
      */
     this._id = ids.next();
 
-    /**
-     * @private
-     * @type {Element}
+    /**
+     * @private
+     * @type {Element}
      */
     this._container = createFormContainer();
     const {
@@ -5914,9 +6310,9 @@ class Form {
       properties = {}
     } = options;
 
-    /**
-     * @private
-     * @type {State}
+    /**
+     * @private
+     * @type {State}
      */
     this._state = {
       initialData: null,
@@ -5940,9 +6336,9 @@ class Form {
     this._emit('form.clear');
   }
 
-  /**
-   * Destroy the form, removing it from DOM,
-   * if attached.
+  /**
+   * Destroy the form, removing it from DOM,
+   * if attached.
    */
   destroy() {
     // destroy form services
@@ -5953,13 +6349,13 @@ class Form {
     this._detach(false);
   }
 
-  /**
-   * Open a form schema with the given initial data.
-   *
-   * @param {Schema} schema
-   * @param {Data} [data]
-   *
-   * @return Promise<{ warnings: Array<any> }>
+  /**
+   * Open a form schema with the given initial data.
+   *
+   * @param {Schema} schema
+   * @param {Data} [data]
+   *
+   * @return Promise<{ warnings: Array<any> }>
    */
   importSchema(schema, data = {}) {
     return new Promise((resolve, reject) => {
@@ -5967,9 +6363,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: {},
@@ -5992,10 +6388,10 @@ class Form {
     });
   }
 
-  /**
-   * Submit the form, triggering all field validations.
-   *
-   * @returns { { data: Data, errors: Errors } }
+  /**
+   * Submit the form, triggering all field validations.
+   *
+   * @returns { { data: Data, errors: Errors } }
    */
   submit() {
     const {
@@ -6022,26 +6418,26 @@ class Form {
     });
   }
 
-  /**
-   * @returns {Errors}
+  /**
+   * @returns {Errors}
    */
   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
@@ -6049,8 +6445,8 @@ class Form {
     return errors;
   }
 
-  /**
-   * @param {Element|string} parentNode
+  /**
+   * @param {Element|string} parentNode
    */
   attachTo(parentNode) {
     if (!parentNode) {
@@ -6068,10 +6464,10 @@ class Form {
     this._detach();
   }
 
-  /**
-   * @private
-   *
-   * @param {boolean} [emit]
+  /**
+   * @private
+   *
+   * @param {boolean} [emit]
    */
   _detach(emit = true) {
     const container = this._container,
@@ -6085,9 +6481,9 @@ class Form {
     parentNode.removeChild(container);
   }
 
-  /**
-   * @param {FormProperty} property
-   * @param {any} value
+  /**
+   * @param {FormProperty} property
+   * @param {any} value
    */
   setProperty(property, value) {
     const properties = minDash.set(this._getState().properties, [property], value);
@@ -6096,21 +6492,21 @@ class Form {
     });
   }
 
-  /**
-   * @param {FormEvent} type
-   * @param {Function} handler
+  /**
+   * @param {FormEvent} type
+   * @param {Function} handler
    */
   off(type, handler) {
     this.get('eventBus').off(type, handler);
   }
 
-  /**
-   * @private
-   *
-   * @param {FormOptions} options
-   * @param {Element} container
-   *
-   * @returns {Injector}
+  /**
+   * @private
+   *
+   * @param {FormOptions} options
+   * @param {Element} container
+   *
+   * @returns {Injector}
    */
   _createInjector(options, container) {
     const {
@@ -6129,17 +6525,17 @@ class Form {
     }, core, ...modules, ...additionalModules]);
   }
 
-  /**
-   * @private
+  /**
+   * @private
    */
   _emit(type, data) {
     this.get('eventBus').fire(type, data);
   }
 
-  /**
-   * @internal
-   *
-   * @param { { add?: boolean, field: any, remove?: number, value?: any } } update
+  /**
+   * @internal
+   *
+   * @param { { add?: boolean, field: any, remove?: number, value?: any } } update
    */
   _update(update) {
     const {
@@ -6147,31 +6543,29 @@ 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)
     });
   }
 
-  /**
-   * @internal
+  /**
+   * @internal
    */
   _getState() {
     return this._state;
   }
 
-  /**
-   * @internal
+  /**
+   * @internal
    */
   _setState(state) {
     this._state = {
@@ -6181,56 +6575,96 @@ class Form {
     this._emit('changed', this._getState());
   }
 
-  /**
-  * @internal
+  /**
+  * @internal
   */
   _getModules() {
     return [ExpressionLanguageModule, MarkdownModule, ViewerCommandsModule];
   }
 
-  /**
-   * @internal
+  /**
+   * @internal
    */
   _onEvent(type, priority, handler) {
     this.get('eventBus').on(type, priority, handler);
   }
 
-  /**
-   * @internal
+  /**
+   * @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;
   }
 
-  /**
-   * @internal
+  /**
+   * @internal
    */
   _applyConditions(toFilter, data) {
     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 = 10;
+const schemaVersion = 11;
 
 /**
  * @typedef { import('./types').CreateFormOptions } CreateFormOptions
@@ -6265,22 +6699,27 @@ 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;
+exports.FormField = FormField;
 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;
@@ -6305,7 +6744,6 @@ exports.clone = clone;
 exports.createForm = createForm;
 exports.createFormContainer = createFormContainer;
 exports.createInjector = createInjector;
-exports.findErrors = findErrors;
 exports.formFields = formFields;
 exports.generateIdForType = generateIdForType;
 exports.generateIndexForType = generateIndexForType;
@@ -6314,7 +6752,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