@react-typed-forms/schemas 15.2.0 → 16.0.0

package/lib/index.js

@@ -1,545 +1,9 @@
-import { newControl, getElementIndex, ensureMetaValue, ControlChange, useControl, useComputed, useRefState, SubscriptionTracker, addAfterChangesCallback, trackedValue, collectChanges, useCalculatedControl, useValueChangeEffect, useValidator, useComponentTracking, useControlEffect, removeElement, RenderArrayElements, addElement } from '@react-typed-forms/core';
-import { useRef, useMemo, useCallback, useEffect } from 'react';
+import { isCompoundField, findField, getTagParam, SchemaTags, ControlDefinitionType, isScalarField, DataRenderType, isDataControl, isGroupControl, createSchemaTree, relativePath, isCompoundNode, fieldPathForDefinition, schemaForFieldPath, isCheckEntryClasses, isGridRenderer, isAutoCompleteClasses, getGroupRendererOptions, ValidatorType, ControlAdornmentType, DisplayDataType, DynamicPropertyType, ExpressionType, GroupRenderType, mergeFields, resolveSchemas, isActionControl, ActionStyle, isDisplayControl, AdornmentPlacement, lookupDataNode, defaultSchemaInterface, createFormState, legacyFormNode, createSchemaDataNode } from '@astroapps/forms-core';
+export * from '@astroapps/forms-core';
+import { useRef, useMemo, useState, useEffect, useCallback } from 'react';
 import clsx from 'clsx';
-import jsonata from 'jsonata';
-import { v4 } from 'uuid';
-import { jsx, Fragment, jsxs } from 'react/jsx-runtime';
-
-/**
- * Enum representing the various field types.
- */
-var FieldType;
-(function (FieldType) {
-  FieldType["String"] = "String";
-  FieldType["Bool"] = "Bool";
-  FieldType["Int"] = "Int";
-  FieldType["Date"] = "Date";
-  FieldType["DateTime"] = "DateTime";
-  FieldType["Time"] = "Time";
-  FieldType["Double"] = "Double";
-  FieldType["EntityRef"] = "EntityRef";
-  FieldType["Compound"] = "Compound";
-  FieldType["AutoId"] = "AutoId";
-  FieldType["Image"] = "Image";
-  FieldType["Any"] = "Any";
-})(FieldType || (FieldType = {}));
-/**
- * Enum representing the various validation message types.
- */
-var ValidationMessageType;
-(function (ValidationMessageType) {
-  ValidationMessageType["NotEmpty"] = "NotEmpty";
-  ValidationMessageType["MinLength"] = "MinLength";
-  ValidationMessageType["MaxLength"] = "MaxLength";
-  ValidationMessageType["NotAfterDate"] = "NotAfterDate";
-  ValidationMessageType["NotBeforeDate"] = "NotBeforeDate";
-})(ValidationMessageType || (ValidationMessageType = {}));
-function findField(fields, field) {
-  return fields.find(x => x.field === field);
-}
-function isScalarField(sf) {
-  return !isCompoundField(sf);
-}
-function isCompoundField(sf) {
-  return sf.type === FieldType.Compound;
-}
-function missingField(field) {
-  return {
-    field: "__missing",
-    type: FieldType.Any,
-    displayName: field
-  };
-}
-function nodeForSchema(field, lookup, parent) {
-  const node = {
-    id: parent ? parent.id + "/" + field.field : field.field,
-    field,
-    getSchema: lookup.getSchema,
-    parent,
-    getChildNode,
-    getChildNodes
-  };
-  return node;
-  function getChildNode(fieldName) {
-    if (isCompoundField(field) && !field.schemaRef && !field.treeChildren) {
-      const childField = field.children.find(x => x.field === fieldName);
-      return childField ? nodeForSchema(childField, lookup, node) : undefined;
-    }
-    return getChildNodes(false, node).find(x => x.field.field === fieldName);
-  }
-  function getChildNodes(noRecurse, withParent) {
-    if (isCompoundField(field)) {
-      if (field.treeChildren) {
-        return noRecurse ? [] : parent.getChildNodes(false, withParent != null ? withParent : node);
-      }
-      const otherRef = field.schemaRef && lookup.getSchema(field.schemaRef);
-      if (otherRef) return otherRef.getChildNodes(false, withParent != null ? withParent : node);
-      return field.children.map(x => nodeForSchema(x, lookup, withParent != null ? withParent : node));
-    }
-    return [];
-  }
-}
-function createSchemaLookup(schemaMap) {
-  const lookup = {
-    getSchema
-  };
-  return lookup;
-  function getSchema(schemaId) {
-    const fields = schemaMap[schemaId];
-    if (fields) {
-      return rootSchemaNode(fields, lookup);
-    }
-    return undefined;
-  }
-}
-function makeSchemaDataNode(schema, control, parent, elementIndex) {
-  const indexId = typeof elementIndex === "number" ? "/" + elementIndex : "";
-  const dataNode = {
-    id: (parent ? parent.id + "/" + schema.field.field : schema.field.field) + indexId,
-    schema,
-    control,
-    parent,
-    elementIndex,
-    getChild,
-    getChildElement
-  };
-  return dataNode;
-  function getChild(childNode) {
-    const objControl = control;
-    if (objControl && objControl.current.isNull) {
-      objControl.value = {};
-    }
-    return makeSchemaDataNode(childNode, objControl == null ? void 0 : objControl.fields[childNode.field.field], dataNode);
-  }
-  function getChildElement(elementIndex) {
-    var _control$elements;
-    return makeSchemaDataNode(schema, control == null || (_control$elements = control.elements) == null ? void 0 : _control$elements[elementIndex], dataNode, elementIndex);
-  }
-}
-function schemaDataForFieldRef(fieldRef, schema) {
-  var _fieldRef$split;
-  return schemaDataForFieldPath((_fieldRef$split = fieldRef == null ? void 0 : fieldRef.split("/")) != null ? _fieldRef$split : [], schema);
-}
-function schemaForFieldRef(fieldRef, schema) {
-  var _fieldRef$split2;
-  return schemaForFieldPath((_fieldRef$split2 = fieldRef == null ? void 0 : fieldRef.split("/")) != null ? _fieldRef$split2 : [], schema);
-}
-function traverseSchemaPath(fieldPath, schema, acc, next) {
-  let i = 0;
-  while (i < fieldPath.length) {
-    const nextField = fieldPath[i];
-    let childNode = nextField === ".." ? schema.parent : schema.getChildNode(nextField);
-    if (!childNode) {
-      childNode = nodeForSchema(missingField(nextField), schema, schema);
-    }
-    acc = next(acc, childNode);
-    schema = childNode;
-    i++;
-  }
-  return acc;
-}
-function traverseData(fieldPath, root, data) {
-  return traverseSchemaPath(fieldPath, root, data, (acc, n) => acc == null ? void 0 : acc[n.field.field]);
-}
-function schemaDataForFieldPath(fieldPath, dataNode) {
-  let i = 0;
-  while (i < fieldPath.length) {
-    var _nextNode;
-    const nextField = fieldPath[i];
-    let nextNode = nextField === ".." ? dataNode.parent : lookupField(nextField);
-    (_nextNode = nextNode) != null ? _nextNode : nextNode = makeSchemaDataNode(nodeForSchema(missingField(nextField), dataNode.schema, dataNode.schema), newControl(undefined));
-    dataNode = nextNode;
-    i++;
-  }
-  return dataNode;
-  function lookupField(field) {
-    const childNode = dataNode.schema.getChildNode(field);
-    if (childNode) {
-      return dataNode.getChild(childNode);
-    }
-    return undefined;
-  }
-}
-function schemaForFieldPath(fieldPath, schema) {
-  let i = 0;
-  while (i < fieldPath.length) {
-    const nextField = fieldPath[i];
-    let childNode = nextField === ".." ? schema.parent : schema.getChildNode(nextField);
-    if (!childNode) {
-      childNode = nodeForSchema(missingField(nextField), schema, schema);
-    }
-    schema = childNode;
-    i++;
-  }
-  return schema;
-}
-function rootSchemaNode(fields, lookup = {
-  getSchema(schemaId) {
-    return undefined;
-  }
-}) {
-  return nodeForSchema({
-    type: FieldType.Compound,
-    field: "",
-    children: fields
-  }, lookup, undefined);
-}
-function getSchemaNodePath(node) {
-  const paths = [];
-  let curNode = node;
-  while (curNode) {
-    paths.push(curNode.field.field);
-    curNode = curNode.parent;
-  }
-  return paths.reverse();
-}
-function isCompoundNode(node) {
-  return isCompoundField(node.field);
-}
-/**
- * Returns the relative path from a parent node to a child node.
- * @param parent
- * @param child
- */
-function relativePath(parent, child) {
-  // return the path from child to parent
-  if (parent.id === child.id) return "";
-  const parentPath = getSchemaNodePath(parent);
-  const childPath = getSchemaNodePath(child);
-  let i = 0;
-  while (i < parentPath.length && i < childPath.length && parentPath[i] === childPath[i]) {
-    i++;
-  }
-  const upLevels = parentPath.length - i;
-  const downPath = childPath.slice(i).join("/");
-  return "../".repeat(upLevels) + downPath;
-}
-var SchemaTags;
-(function (SchemaTags) {
-  SchemaTags["NoControl"] = "_NoControl";
-  SchemaTags["HtmlEditor"] = "_HtmlEditor";
-  SchemaTags["ControlGroup"] = "_ControlGroup:";
-  SchemaTags["ControlRef"] = "_ControlRef:";
-  SchemaTags["IdField"] = "_IdField:";
-})(SchemaTags || (SchemaTags = {}));
-function getTagParam(field, tag) {
-  var _field$tags;
-  return (_field$tags = field.tags) == null || (_field$tags = _field$tags.find(x => x.startsWith(tag))) == null ? void 0 : _field$tags.substring(tag.length);
-}
-function makeParamTag(tag, value) {
-  return `${tag}${value}`;
-}
-
-var ControlDefinitionType;
-(function (ControlDefinitionType) {
-  ControlDefinitionType["Data"] = "Data";
-  ControlDefinitionType["Group"] = "Group";
-  ControlDefinitionType["Display"] = "Display";
-  ControlDefinitionType["Action"] = "Action";
-})(ControlDefinitionType || (ControlDefinitionType = {}));
-var DynamicPropertyType;
-(function (DynamicPropertyType) {
-  DynamicPropertyType["Visible"] = "Visible";
-  DynamicPropertyType["DefaultValue"] = "DefaultValue";
-  DynamicPropertyType["Readonly"] = "Readonly";
-  DynamicPropertyType["Disabled"] = "Disabled";
-  DynamicPropertyType["Display"] = "Display";
-  DynamicPropertyType["Style"] = "Style";
-  DynamicPropertyType["LayoutStyle"] = "LayoutStyle";
-  DynamicPropertyType["AllowedOptions"] = "AllowedOptions";
-  DynamicPropertyType["Label"] = "Label";
-  DynamicPropertyType["ActionData"] = "ActionData";
-})(DynamicPropertyType || (DynamicPropertyType = {}));
-var AdornmentPlacement;
-(function (AdornmentPlacement) {
-  AdornmentPlacement["ControlStart"] = "ControlStart";
-  AdornmentPlacement["ControlEnd"] = "ControlEnd";
-  AdornmentPlacement["LabelStart"] = "LabelStart";
-  AdornmentPlacement["LabelEnd"] = "LabelEnd";
-})(AdornmentPlacement || (AdornmentPlacement = {}));
-var ControlAdornmentType;
-(function (ControlAdornmentType) {
-  ControlAdornmentType["Tooltip"] = "Tooltip";
-  ControlAdornmentType["Accordion"] = "Accordion";
-  ControlAdornmentType["HelpText"] = "HelpText";
-  ControlAdornmentType["Icon"] = "Icon";
-  ControlAdornmentType["SetField"] = "SetField";
-  ControlAdornmentType["Optional"] = "Optional";
-})(ControlAdornmentType || (ControlAdornmentType = {}));
-var DataRenderType;
-(function (DataRenderType) {
-  DataRenderType["Standard"] = "Standard";
-  DataRenderType["Textfield"] = "Textfield";
-  DataRenderType["Radio"] = "Radio";
-  DataRenderType["HtmlEditor"] = "HtmlEditor";
-  DataRenderType["IconList"] = "IconList";
-  DataRenderType["CheckList"] = "CheckList";
-  DataRenderType["UserSelection"] = "UserSelection";
-  DataRenderType["Synchronised"] = "Synchronised";
-  DataRenderType["IconSelector"] = "IconSelector";
-  DataRenderType["DateTime"] = "DateTime";
-  DataRenderType["Checkbox"] = "Checkbox";
-  DataRenderType["Dropdown"] = "Dropdown";
-  DataRenderType["DisplayOnly"] = "DisplayOnly";
-  DataRenderType["Group"] = "Group";
-  DataRenderType["NullToggle"] = "NullToggle";
-  DataRenderType["Autocomplete"] = "Autocomplete";
-  DataRenderType["Jsonata"] = "Jsonata";
-  DataRenderType["Array"] = "Array";
-  DataRenderType["ArrayElement"] = "ArrayElement";
-})(DataRenderType || (DataRenderType = {}));
-var SyncTextType;
-(function (SyncTextType) {
-  SyncTextType["Camel"] = "Camel";
-  SyncTextType["Snake"] = "Snake";
-  SyncTextType["Pascal"] = "Pascal";
-})(SyncTextType || (SyncTextType = {}));
-var GroupRenderType;
-(function (GroupRenderType) {
-  GroupRenderType["Standard"] = "Standard";
-  GroupRenderType["Grid"] = "Grid";
-  GroupRenderType["Flex"] = "Flex";
-  GroupRenderType["Tabs"] = "Tabs";
-  GroupRenderType["GroupElement"] = "GroupElement";
-  GroupRenderType["SelectChild"] = "SelectChild";
-})(GroupRenderType || (GroupRenderType = {}));
-var DisplayDataType;
-(function (DisplayDataType) {
-  DisplayDataType["Text"] = "Text";
-  DisplayDataType["Html"] = "Html";
-  DisplayDataType["Icon"] = "Icon";
-  DisplayDataType["Custom"] = "Custom";
-})(DisplayDataType || (DisplayDataType = {}));
-function visitControlDefinition(x, visitor, defaultValue) {
-  switch (x.type) {
-    case ControlDefinitionType.Action:
-      return visitor.action(x);
-    case ControlDefinitionType.Data:
-      return visitor.data(x);
-    case ControlDefinitionType.Display:
-      return visitor.display(x);
-    case ControlDefinitionType.Group:
-      return visitor.group(x);
-    default:
-      return defaultValue(x);
-  }
-}
-function isGridRenderer(options) {
-  return options.type === GroupRenderType.Grid;
-}
-function isSelectChildRenderer(options) {
-  return options.type === GroupRenderType.SelectChild;
-}
-function isTabsRenderer(options) {
-  return options.type === GroupRenderType.Tabs;
-}
-function isFlexRenderer(options) {
-  return options.type === GroupRenderType.Flex;
-}
-function isDisplayOnlyRenderer(options) {
-  return options.type === DataRenderType.DisplayOnly;
-}
-function isTextfieldRenderer(options) {
-  return options.type === DataRenderType.Textfield;
-}
-function isDateTimeRenderer(options) {
-  return options.type === DataRenderType.DateTime;
-}
-function isAutocompleteRenderer(options) {
-  return options.type === DataRenderType.Autocomplete;
-}
-function isAutoCompleteClasses(options) {
-  switch (options == null ? void 0 : options.type) {
-    case DataRenderType.Autocomplete:
-      return true;
-    default:
-      return false;
-  }
-}
-function isDataGroupRenderer(options) {
-  return (options == null ? void 0 : options.type) === DataRenderType.Group;
-}
-function isArrayRenderer(options) {
-  return options.type === DataRenderType.Array;
-}
-function isDataControl(c) {
-  return c.type === ControlDefinitionType.Data;
-}
-function isGroupControl(c) {
-  return c.type === ControlDefinitionType.Group;
-}
-function isActionControl(c) {
-  return c.type === ControlDefinitionType.Action;
-}
-function isDisplayControl(c) {
-  return c.type === ControlDefinitionType.Display;
-}
-function isCheckEntryClasses(options) {
-  switch (options == null ? void 0 : options.type) {
-    case DataRenderType.Radio:
-    case DataRenderType.CheckList:
-      return true;
-    default:
-      return false;
-  }
-}
-class FormNodeImpl {
-  constructor(id, definition, tree, parent) {
-    this.id = void 0;
-    this.definition = void 0;
-    this.tree = void 0;
-    this.parent = void 0;
-    this.children = [];
-    this.id = id;
-    this.definition = definition;
-    this.tree = tree;
-    this.parent = parent;
-  }
-  getChildNodes() {
-    return this.children;
-  }
-}
-class FormTree {
-  createTempNode(id, definition, children, parent) {
-    const tempNode = {
-      id,
-      definition,
-      tree: this,
-      parent,
-      getChildNodes: () => children != null ? children : this.createChildNodes(tempNode, definition.children)
-    };
-    return tempNode;
-  }
-  createChildNodes(parent, definitions) {
-    var _definitions$map;
-    return (_definitions$map = definitions == null ? void 0 : definitions.map((x, i) => this.createTempNode(parent.id + "_" + i, x, undefined, parent))) != null ? _definitions$map : [];
-  }
-}
-class FormTreeImpl extends FormTree {
-  constructor(forms) {
-    super();
-    this.forms = void 0;
-    this.controlMap = {};
-    this.rootNode = void 0;
-    this.idCount = 1;
-    this.forms = forms;
-    this.rootNode = new FormNodeImpl("", {
-      type: "Group"
-    }, this);
-  }
-  getByRefId(id) {
-    return this.controlMap[id];
-  }
-  register(node) {
-    this.controlMap[node.id] = node;
-    node.getChildNodes().forEach(x => this.register(x));
-  }
-  addChild(parent, control) {
-    var _control$children;
-    const node = new FormNodeImpl(control.id ? control.id : "c" + this.idCount++, control, this, parent);
-    (_control$children = control.children) == null || _control$children.forEach(x => this.addChild(node, x));
-    parent.getChildNodes().push(node);
-    this.register(node);
-    return node;
-  }
-  getForm(formId) {
-    return this.forms.getForm(formId);
-  }
-}
-function legacyFormNode(definition) {
-  return createFormTree([definition]).rootNode.getChildNodes()[0];
-}
-function createFormTree(controls, getForm = {
-  getForm: () => undefined
-}) {
-  const tree = new FormTreeImpl(getForm);
-  controls.forEach(x => tree.addChild(tree.rootNode, x));
-  return tree;
-}
-function createFormLookup(formMap) {
-  const lookup = {
-    getForm
-  };
-  const forms = Object.fromEntries(Object.entries(formMap).map(([k, v]) => [k, createFormTree(v, lookup)]));
-  return lookup;
-  function getForm(formId) {
-    return forms[formId];
-  }
-}
-function fieldPathForDefinition(c) {
-  const fieldName = isGroupControl(c) ? c.compoundField : isDataControl(c) ? c.field : undefined;
-  return fieldName == null ? void 0 : fieldName.split("/");
-}
-function lookupDataNode(c, parentNode) {
-  const fieldNamePath = fieldPathForDefinition(c);
-  return fieldNamePath ? schemaDataForFieldPath(fieldNamePath, parentNode) : undefined;
-}
-function traverseParents(current, get, until) {
-  let outArray = [];
-  while (current && !(until != null && until(current))) {
-    outArray.push(get(current));
-    current = current.parent;
-  }
-  return outArray.reverse();
-}
-function getRootDataNode(dataNode) {
-  while (dataNode.parent) {
-    dataNode = dataNode.parent;
-  }
-  return dataNode;
-}
-function getJsonPath(dataNode) {
-  return traverseParents(dataNode, d => d.elementIndex == null ? d.schema.field.field : d.elementIndex, x => !x.parent);
-}
-function getSchemaPath(schemaNode) {
-  return traverseParents(schemaNode, d => d.field, x => !x.parent);
-}
-function getSchemaFieldList(schema) {
-  return schema.getChildNodes().map(x => x.field);
-}
-/**
- * @deprecated use visitFormNodeData instead
- */
-function visitControlDataArray(controls, context, cb) {
-  if (!controls) return undefined;
-  for (const c of controls) {
-    const r = visitControlData(c, context, cb);
-    if (r !== undefined) return r;
-  }
-  return undefined;
-}
-/**
- * @deprecated use visitFormDataInContext instead
- */
-function visitControlData(definition, ctx, cb) {
-  return visitFormDataInContext(ctx, legacyFormNode(definition), (n, d) => cb(d, n));
-}
-function visitFormData(node, dataNode, cb, notSelf) {
-  const def = node.definition;
-  const result = !notSelf && isDataControl(def) ? cb(dataNode, def) : undefined;
-  if (result !== undefined) return result;
-  if (dataNode.elementIndex == null && dataNode.schema.field.collection) {
-    const _l = dataNode.control.elements.length;
-    for (let i = 0; i < _l; i++) {
-      const elemChild = dataNode.getChildElement(i);
-      const elemResult = visitFormData(node, elemChild, cb);
-      if (elemResult !== undefined) return elemResult;
-    }
-    return undefined;
-  }
-  if (dataNode.control.isNull) return undefined;
-  const children = node.getChildNodes();
-  const l = children.length;
-  for (let i = 0; i < l; i++) {
-    const elemResult = visitFormDataInContext(dataNode, children[i], cb);
-    if (elemResult !== undefined) return elemResult;
-  }
-  return undefined;
-}
-function visitFormDataInContext(parentContext, node, cb) {
-  const dataNode = lookupDataNode(node.definition, parentContext);
-  return visitFormData(node, dataNode != null ? dataNode : parentContext, cb, !dataNode);
-}
+import { getElementIndex, ensureMetaValue, newControl, ControlChange, useControl, createScopedEffect, removeElement, RenderArrayElements, addElement, useComponentTracking } from '@react-typed-forms/core';
+import { jsxs, Fragment, jsx } from 'react/jsx-runtime';
 
 function _extends() {
   return _extends = Object.assign ? Object.assign.bind() : function (n) {
@@ -560,143 +24,6 @@ function _objectWithoutPropertiesLoose(r, e) {
   return t;
 }
 
-function buildSchema(def) {
-  return Object.entries(def).map(x => x[1](x[0]));
-}
-function stringField(displayName, options) {
-  return makeScalarField(_extends({
-    type: FieldType.String,
-    displayName
-  }, options));
-}
-function stringOptionsField(displayName, ...options) {
-  return makeScalarField({
-    type: FieldType.String,
-    displayName,
-    options
-  });
-}
-function withScalarOptions(options, v) {
-  return n => _extends({}, v(n), options);
-}
-function makeScalarField(options) {
-  return n => _extends({}, defaultScalarField(n, n), options);
-}
-function makeCompoundField(options) {
-  return n => _extends({}, defaultCompoundField(n, n, false), options);
-}
-function intField(displayName, options) {
-  return makeScalarField(_extends({
-    type: FieldType.Int,
-    displayName
-  }, options));
-}
-function doubleField(displayName, options) {
-  return makeScalarField(_extends({
-    type: FieldType.Double,
-    displayName
-  }, options));
-}
-function dateField(displayName, options) {
-  return makeScalarField(_extends({
-    type: FieldType.Date,
-    displayName
-  }, options));
-}
-function timeField(displayName, options) {
-  return makeScalarField(_extends({
-    type: FieldType.Time,
-    displayName
-  }, options));
-}
-function dateTimeField(displayName, options) {
-  return makeScalarField(_extends({
-    type: FieldType.DateTime,
-    displayName
-  }, options));
-}
-function boolField(displayName, options) {
-  return makeScalarField(_extends({
-    type: FieldType.Bool,
-    displayName
-  }, options));
-}
-function compoundField(displayName, fields, other) {
-  return field => _extends({}, defaultCompoundField(field, displayName, false), other, {
-    children: fields
-  });
-}
-function defaultScalarField(field, displayName) {
-  return {
-    field,
-    displayName,
-    type: FieldType.String
-  };
-}
-function defaultCompoundField(field, displayName, collection) {
-  return {
-    field,
-    displayName,
-    type: FieldType.Compound,
-    collection,
-    children: []
-  };
-}
-function mergeField(field, mergeInto) {
-  const existing = mergeInto.find(x => x.field === field.field);
-  if (existing) {
-    return mergeInto.map(x => x !== existing ? x : _extends({}, x, {
-      onlyForTypes: mergeTypes(x.onlyForTypes, field.onlyForTypes)
-    }));
-  }
-  return [...mergeInto, field];
-  function mergeTypes(f, s) {
-    if (!f) return s;
-    if (!s) return f;
-    const extras = s.filter(x => !f.includes(x));
-    return extras.length ? [...f, ...extras] : f;
-  }
-}
-function mergeFields(fields, name, value, newFields) {
-  const withType = fields.map(x => x.isTypeField ? addFieldOption(x, name, value) : x);
-  return newFields.map(x => _extends({}, x, {
-    onlyForTypes: [value]
-  })).reduce((af, x) => mergeField(x, af), withType);
-}
-function addFieldOption(typeField, name, value) {
-  var _typeField$options;
-  const options = (_typeField$options = typeField.options) != null ? _typeField$options : [];
-  if (options.some(x => x.value === value)) return typeField;
-  return _extends({}, typeField, {
-    options: [...options, {
-      name,
-      value
-    }]
-  });
-}
-function resolveSchemas(schemaMap) {
-  const out = {};
-  function resolveSchemaType(type) {
-    if (type in out) {
-      return out[type];
-    }
-    const resolvedFields = [];
-    out[type] = resolvedFields;
-    schemaMap[type].forEach(x => {
-      if (isCompoundField(x) && x.schemaRef) {
-        resolvedFields.push(_extends({}, x, {
-          children: resolveSchemaType(x.schemaRef)
-        }));
-      } else {
-        resolvedFields.push(x);
-      }
-    });
-    return resolvedFields;
-  }
-  Object.keys(schemaMap).forEach(resolveSchemaType);
-  return out;
-}
-
 /**
  * Applies default values to the given record based on the provided schema fields.
  * @param v - The record to apply default values to.
@@ -756,7 +83,8 @@ function defaultValueForField(sf, required) {
   const isRequired = !!(required || sf.required);
   if (isCompoundField(sf)) {
     if (isRequired) {
-      const childValue = defaultValueForFields(sf.children);
+      var _sf$children;
+      const childValue = defaultValueForFields((_sf$children = sf.children) != null ? _sf$children : []);
       return sf.collection ? [childValue] : childValue;
     }
     return sf.notNullable ? sf.collection ? [] : {} : undefined;
@@ -773,7 +101,8 @@ function defaultValueForField(sf, required) {
  */
 function elementValueForField(sf) {
   if (isCompoundField(sf)) {
-    return defaultValueForFields(sf.children);
+    var _sf$children2;
+    return defaultValueForFields((_sf$children2 = sf.children) != null ? _sf$children2 : []);
   }
   return sf.defaultValue;
 }
@@ -884,34 +213,7 @@ function findNonDataGroups(controls) {
  * @returns The control definitions with missing controls added.
  */
 function addMissingControls(fields, controls, warning) {
-  return addMissingControlsForSchema(rootSchemaNode(fields), controls, warning);
-}
-function registerSchemaEntries(formNode, parentSchema) {
-  const formToSchema = {};
-  const schemaToForm = {};
-  function register(node, parentSchema) {
-    const c = node.definition;
-    const controlPath = fieldPathForDefinition(c);
-    let dataSchema = controlPath ? schemaForFieldPath(controlPath, parentSchema) : undefined;
-    if (isGroupControl(c) && dataSchema == null) dataSchema = parentSchema;
-    if (dataSchema) {
-      var _schemaToForm$dataSch;
-      formToSchema[node.id] = dataSchema;
-      const formNodes = (_schemaToForm$dataSch = schemaToForm[dataSchema.id]) != null ? _schemaToForm$dataSch : [];
-      formNodes.push(node);
-      schemaToForm[dataSchema.id] = formNodes;
-    }
-    node.getChildNodes().forEach(x => {
-      var _dataSchema;
-      return register(x, (_dataSchema = dataSchema) != null ? _dataSchema : parentSchema);
-    });
-  }
-  register(formNode, parentSchema);
-  return {
-    formToSchema,
-    schemaToForm,
-    register
-  };
+  return addMissingControlsForSchema(createSchemaTree(fields).rootNode, controls, warning);
 }
 /**
  * Adds missing controls to the provided control definitions based on the schema fields.
@@ -921,60 +223,51 @@ function registerSchemaEntries(formNode, parentSchema) {
  * @returns The control definitions with missing controls added.
  */
 function addMissingControlsForSchema(schema, controls, warning) {
-  var _toDefinition$childre;
-  const tree = createFormTree(controls);
-  addMissingControlsToForm(schema, tree, warning);
-  return (_toDefinition$childre = toDefinition(tree.rootNode).children) != null ? _toDefinition$childre : [];
+  const controlMap = {};
+  const schemaControlMap = {};
+  const rootControls = controls.map(c => toControlAndSchema(c, schema));
+  const rootSchema = {
+    schema,
+    children: rootControls
+  };
+  addSchemaMapEntry("", rootSchema);
+  rootControls.forEach(addReferences);
+  const fields = schema.getChildNodes();
+  fields.forEach(addMissing);
+  return rootControls.map(toDefinition);
   function toDefinition(c) {
-    const children = c.getChildNodes().length ? c.getChildNodes().map(toDefinition) : null;
-    return _extends({}, c.definition, {
+    const children = c.children.length ? c.children.map(toDefinition) : null;
+    return _extends({}, c.control, {
       children
     });
   }
-}
-/**
- * Adds missing controls to the provided form tree based on the schema fields.
- * @param schema - The root schema node to use for adding missing controls.
- * @param tree - The form tree to add missing controls to.
- * @param warning - An optional function to call with warning messages.
- */
-function addMissingControlsToForm(schema, tree, warning) {
-  const {
-    formToSchema,
-    schemaToForm,
-    register
-  } = registerSchemaEntries(tree.rootNode, schema);
-  schema.getChildNodes().forEach(addMissing);
-  return;
   function addMissing(schemaNode) {
     if (fieldHasTag(schemaNode.field, SchemaTags.NoControl)) return;
     let skipChildren = false;
-    const existingControls = schemaToForm[schemaNode.id];
+    const existingControls = schemaControlMap[schemaNode.id];
     if (!existingControls) {
       const eligibleParents = getEligibleParents(schemaNode);
       const desiredGroup = getTagParam(schemaNode.field, SchemaTags.ControlGroup);
-      let parentGroup = desiredGroup ? tree.getByRefId(desiredGroup) : undefined;
+      let parentGroup = desiredGroup ? controlMap[desiredGroup] : undefined;
       if (!parentGroup && desiredGroup) warning == null || warning("No group '" + desiredGroup + "' for " + schemaNode.id);
-      if (parentGroup && eligibleParents.indexOf(formToSchema[parentGroup.id].id) < 0) {
+      if (parentGroup && eligibleParents.indexOf(parentGroup.schema.id) < 0) {
         warning == null || warning(`Target group '${desiredGroup}' is not an eligible parent for '${schemaNode.id}'`);
         parentGroup = undefined;
       }
       if (!parentGroup && eligibleParents.length) {
-        var _schemaToForm$eligibl;
-        parentGroup = (_schemaToForm$eligibl = schemaToForm[eligibleParents[0]]) == null ? void 0 : _schemaToForm$eligibl[0];
+        var _schemaControlMap$eli;
+        parentGroup = (_schemaControlMap$eli = schemaControlMap[eligibleParents[0]]) == null ? void 0 : _schemaControlMap$eli[0];
       }
       if (parentGroup) {
         const newControl = defaultControlForField(schemaNode.field, true);
         skipChildren = !!newControl.childRefId;
-        const parentSchemaNode = formToSchema[parentGroup.id];
-        newControl.field = relativePath(parentSchemaNode, schemaNode);
-        const newNode = tree.addChild(parentGroup, newControl);
-        register(newNode, parentSchemaNode);
+        newControl.field = relativePath(parentGroup.schema, schemaNode);
+        parentGroup.children.push(toControlAndSchema(newControl, parentGroup.schema, parentGroup));
       } else warning == null || warning("Could not find a parent group for: " + schemaNode.id);
     } else {
-      skipChildren = existingControls.some(x => x.definition.childRefId);
+      skipChildren = existingControls.some(x => x.control.childRefId);
     }
-    if (!skipChildren) schemaNode.getChildNodes(true).forEach(addMissing);
+    if (!skipChildren) schemaNode.getChildNodes().forEach(addMissing);
   }
   function getEligibleParents(schemaNode) {
     const eligibleParents = [];
@@ -982,17 +275,53 @@ function addMissingControlsToForm(schema, tree, warning) {
     while (parent) {
       eligibleParents.push(parent.id);
       if (parent.field.collection) break;
-      if (!parent.parent) parent.getChildNodes(true).forEach(addCompound);
+      if (!parent.parent) parent.getChildNodes().forEach(addCompound);
       parent = parent.parent;
     }
     return eligibleParents;
     function addCompound(node) {
       if (isCompoundNode(node) && !node.field.collection) {
         eligibleParents.push(node.id);
-        node.getChildNodes(true).forEach(addCompound);
+        node.getChildNodes().forEach(addCompound);
+      }
+    }
+  }
+  function addReferences(c) {
+    c.children.forEach(addReferences);
+    if (c.control.childRefId) {
+      const ref = controlMap[c.control.childRefId];
+      if (ref) {
+        ref.children.forEach(x => toControlAndSchema(x.control, c.schema, c, true));
+        return;
       }
+      console.warn("Missing reference", c.control.childRefId);
     }
   }
+  function addSchemaMapEntry(schemaId, entry) {
+    if (!schemaControlMap[schemaId]) schemaControlMap[schemaId] = [];
+    schemaControlMap[schemaId].push(entry);
+  }
+  function toControlAndSchema(c, parentSchema, parentNode, dontRegister) {
+    var _c$children$map, _c$children;
+    const controlPath = fieldPathForDefinition(c);
+    let dataSchema = controlPath ? schemaForFieldPath(controlPath, parentSchema) : undefined;
+    if (isGroupControl(c) && dataSchema == null) dataSchema = parentSchema;
+    const entry = {
+      schema: dataSchema,
+      control: c,
+      children: [],
+      parent: parentNode
+    };
+    entry.children = (_c$children$map = (_c$children = c.children) == null ? void 0 : _c$children.map(x => {
+      var _dataSchema;
+      return toControlAndSchema(x, (_dataSchema = dataSchema) != null ? _dataSchema : parentSchema, entry, dontRegister);
+    })) != null ? _c$children$map : [];
+    if (!dontRegister && c.id) controlMap[c.id] = entry;
+    if (dataSchema) {
+      addSchemaMapEntry(dataSchema.id, entry);
+    }
+    return entry;
+  }
 }
 /**
  * Custom hook to use an updated reference.
@@ -1004,41 +333,19 @@ function useUpdatedRef(a) {
   r.current = a;
   return r;
 }
-/**
- * Checks if a control definition is readonly.
- * @param c - The control definition to check.
- * @returns True if the control definition is readonly, false otherwise.
- */
-function isControlReadonly(c) {
-  return isDataControl(c) && !!c.readonly;
-}
-/**
- * Checks if a control definition is disabled.
- * @param c - The control definition to check.
- * @returns True if the control definition is disabled, false otherwise.
- */
-function isControlDisabled(c) {
-  return isDataControl(c) && !!c.disabled;
-}
-/**
- * Returns the display-only render options for a control definition.
- * @param d - The control definition to get the display-only render options for.
- * @returns The display-only render options, or undefined if not applicable.
- */
-function getDisplayOnlyOptions(d) {
-  return isDataControl(d) && d.renderOptions && isDisplayOnlyRenderer(d.renderOptions) ? d.renderOptions : undefined;
-}
 /**
  * Cleans data for a schema based on the provided schema fields.
  * @param v - The data to clean.
- * @param fields - The schema fields to use for cleaning the data.
+ * @param schemaNode
  * @param removeIfDefault - Flag indicating if default values should be removed.
  * @returns The cleaned data.
  */
-function cleanDataForSchema(v, fields, removeIfDefault) {
+function cleanDataForSchema(v, schemaNode, removeIfDefault) {
+  var _fields$find;
   if (!v) return v;
-  const typeField = fields.find(x => x.isTypeField);
-  const typeValue = typeField ? v[typeField.field] : undefined;
+  const fields = schemaNode.getResolvedFields();
+  const typeField = (_fields$find = fields.find(x => x.isTypeField)) == null ? void 0 : _fields$find.field;
+  const typeValue = typeField ? v[typeField] : undefined;
   const cleanableFields = !removeIfDefault ? fields.filter(x => {
     var _x$onlyForTypes$lengt, _x$onlyForTypes;
     return isCompoundField(x) || ((_x$onlyForTypes$lengt = (_x$onlyForTypes = x.onlyForTypes) == null ? void 0 : _x$onlyForTypes.length) != null ? _x$onlyForTypes$lengt : 0) > 0;
@@ -1053,13 +360,13 @@ function cleanDataForSchema(v, fields, removeIfDefault) {
       return;
     }
     if (isCompoundField(x)) {
-      const childFields = x.treeChildren ? fields : x.children;
+      const childNode = schemaNode.createChildNode(x);
       if (x.collection) {
         if (Array.isArray(childValue)) {
-          out[x.field] = childValue.map(cv => cleanDataForSchema(cv, childFields, removeIfDefault));
+          out[x.field] = childValue.map(cv => cleanDataForSchema(cv, childNode, removeIfDefault));
         }
       } else {
-        out[x.field] = cleanDataForSchema(childValue, childFields, removeIfDefault);
+        out[x.field] = cleanDataForSchema(childValue, childNode, removeIfDefault);
       }
     }
     function canBeNull() {
@@ -1077,45 +384,28 @@ function cleanDataForSchema(v, fields, removeIfDefault) {
  * @returns An array of referenced classes.
  */
 function getAllReferencedClasses(c, collectExtra) {
-  var _c$children, _collectExtra;
-  const childClasses = (_c$children = c.children) == null ? void 0 : _c$children.flatMap(x => getAllReferencedClasses(x, collectExtra));
+  var _c$children2, _collectExtra;
+  const childClasses = (_c$children2 = c.children) == null ? void 0 : _c$children2.flatMap(x => getAllReferencedClasses(x, collectExtra));
   const go = getGroupClassOverrides(c);
   const {
     entryWrapperClass,
     selectedClass,
     notSelectedClass
   } = isDataControl(c) && isCheckEntryClasses(c.renderOptions) ? c.renderOptions : {};
+  const groupOptions = isGroupControl(c) ? c.groupOptions : undefined;
+  const gridClasses = groupOptions && isGridRenderer(groupOptions) ? [groupOptions.rowClass] : [];
   const {
     listContainerClass,
     listEntryClass,
     chipContainerClass,
     chipCloseButtonClass
   } = isDataControl(c) && isAutoCompleteClasses(c.renderOptions) ? c.renderOptions : {};
-  const tc = clsx([c.styleClass, c.layoutClass, c.labelClass, ...Object.values(go), ...((_collectExtra = collectExtra == null ? void 0 : collectExtra(c)) != null ? _collectExtra : []), entryWrapperClass, selectedClass, notSelectedClass, listContainerClass, listEntryClass, chipContainerClass, chipCloseButtonClass].map(getOverrideClass));
+  const tc = clsx([c.styleClass, c.layoutClass, c.labelClass, c.textClass, c.labelTextClass, ...gridClasses, ...Object.values(go), ...((_collectExtra = collectExtra == null ? void 0 : collectExtra(c)) != null ? _collectExtra : []), entryWrapperClass, selectedClass, notSelectedClass, listContainerClass, listEntryClass, chipContainerClass, chipCloseButtonClass].map(getOverrideClass));
   if (childClasses && !tc) return childClasses;
   if (!tc) return [];
   if (childClasses) return [tc, ...childClasses];
   return [tc];
 }
-/**
- * Converts a JSON path array to a string.
- * @param jsonPath - The JSON path array to convert.
- * @param customIndex - Optional function to customize the index format.
- * @returns The JSON path string.
- */
-function jsonPathString(jsonPath, customIndex) {
-  let out = "";
-  jsonPath.forEach((v, i) => {
-    if (typeof v === "number") {
-      var _customIndex;
-      out += (_customIndex = customIndex == null ? void 0 : customIndex(v)) != null ? _customIndex : "[" + v + "]";
-    } else {
-      if (i > 0) out += ".";
-      out += v;
-    }
-  });
-  return out;
-}
 /**
  * Finds a child control definition within a parent control definition.
  * @param parent - The parent control definition.
@@ -1232,14 +522,6 @@ function deepMerge(value, fallback) {
 function coerceToString(v) {
   return v == null ? "" : typeof v === "object" ? "error: " + JSON.stringify(v) : v.toString();
 }
-/**
- * Returns the group renderer options for a control definition.
- * @param {ControlDefinition} def - The control definition to get the group renderer options for.
- * @returns {GroupRenderOptions | undefined} - The group renderer options, or undefined if not applicable.
- */
-function getGroupRendererOptions(def) {
-  return isGroupControl(def) ? def.groupOptions : isDataControl(def) && isDataGroupRenderer(def.renderOptions) ? def.renderOptions.groupOptions : undefined;
-}
 /**
  * Returns the group class overrides for a control definition.
  * @param {ControlDefinition} def - The control definition to get the group class overrides for.
@@ -1259,25 +541,17 @@ function getGroupClassOverrides(def) {
   if (childLabelClass) out.labelClass = childLabelClass;
   return out;
 }
-/**
- * Checks if a control definition is display-only.
- * @param {ControlDefinition} def - The control definition to check.
- * @returns {boolean} - True if the control definition is display-only, false otherwise.
- */
-function isControlDisplayOnly(def) {
-  var _getGroupRendererOpti;
-  return Boolean((_getGroupRendererOpti = getGroupRendererOptions(def)) == null ? void 0 : _getGroupRendererOpti.displayOnly);
-}
 /**
  * Combines multiple action handlers into a single handler.
  * @param {...(ControlActionHandler | undefined)[]} handlers - The action handlers to combine.
  * @returns {ControlActionHandler} - The combined action handler.
  */
 function actionHandlers(...handlers) {
+  const nonNullHandlers = handlers.filter(x => x != null);
+  if (nonNullHandlers.length === 0) return undefined;
   return (actionId, actionData, ctx) => {
-    for (let i = 0; i < handlers.length; i++) {
-      var _handlers$i;
-      const res = (_handlers$i = handlers[i]) == null ? void 0 : _handlers$i.call(handlers, actionId, actionData, ctx);
+    for (let i = 0; i < nonNullHandlers.length; i++) {
+      const res = nonNullHandlers[i](actionId, actionData, ctx);
       if (res) return res;
     }
     return undefined;
@@ -1425,28 +699,13 @@ function validationVisitor(onInvalid) {
     return undefined;
   };
 }
-
-var ValidatorType;
-(function (ValidatorType) {
-  ValidatorType["Jsonata"] = "Jsonata";
-  ValidatorType["Date"] = "Date";
-  ValidatorType["Length"] = "Length";
-})(ValidatorType || (ValidatorType = {}));
-var DateComparison;
-(function (DateComparison) {
-  DateComparison["NotBefore"] = "NotBefore";
-  DateComparison["NotAfter"] = "NotAfter";
-})(DateComparison || (DateComparison = {}));
-
-var ExpressionType;
-(function (ExpressionType) {
-  ExpressionType["Jsonata"] = "Jsonata";
-  ExpressionType["Data"] = "Data";
-  ExpressionType["DataMatch"] = "FieldValue";
-  ExpressionType["UserMatch"] = "UserMatch";
-  ExpressionType["NotEmpty"] = "NotEmpty";
-  ExpressionType["UUID"] = "UUID";
-})(ExpressionType || (ExpressionType = {}));
+function useExpression(defaultValue, runExpression, expression, coerce, bindings) {
+  const value = useControl(defaultValue);
+  createScopedEffect(scope => {
+    if (expression != null && expression.type) runExpression(scope, expression, x => value.value = coerce(x), bindings);else value.value = defaultValue;
+  }, value);
+  return value;
+}
 
 function dataControl(field, title, options) {
   return _extends({
@@ -1609,535 +868,7 @@ function applyExtensionsToSchema(schemaMap, extensions) {
   return resolveSchemas(extensions.reduce(applyExtensionToSchema, schemaMap));
 }
 
-/**
- * Creates a dynamic hook generator.
- * @template A - The type of the hook result.
- * @template P - The type of the hook context.
- * @template S - The type of the hook state.
- * @param runHook - The function to run the hook.
- * @param state - The initial state of the hook.
- * @param deps - The dependencies of the hook.
- * @returns The dynamic hook generator.
- */
-function makeHook(runHook, state, deps) {
-  return {
-    deps,
-    state,
-    runHook
-  };
-}
-/**
- * Converts an array of dependencies to a dependency string.
- * @template A - The type of the dependencies.
- * @param deps - The array of dependencies.
- * @param asHookDep - The function to convert a dependency to a hook dependency.
- * @returns The dependency string.
- */
-function makeHookDepString(deps, asHookDep) {
-  return deps.map(x => toDepString(asHookDep(x))).join(",");
-}
-/**
- * Custom hook to use dynamic hooks.
- * @template P - The type of the hook context.
- * @template Hooks - The type of the hooks.
- * @param hooks - The hooks to use.
- * @returns A function that takes the hook context and returns the hook values.
- */
-function useDynamicHooks(hooks) {
-  const hookEntries = Object.entries(hooks);
-  const deps = makeHookDepString(hookEntries, x => x[1].deps);
-  const ref = useRef({});
-  const s = ref.current;
-  hookEntries.forEach(x => s[x[0]] = x[1].state);
-  return useCallback(p => {
-    return Object.fromEntries(hookEntries.map(([f, hg]) => [f, hg.runHook(p, ref.current[f])]));
-  }, [deps]);
-}
-/**
- * Converts a value to a dependency string.
- * @param x - The value to convert.
- * @returns The dependency string.
- */
-function toDepString(x) {
-  if (x === undefined) return "_";
-  if (x === null) return "~";
-  return x.toString();
-}
-
-function optionalHook(expr, useHook, coerce) {
-  return expr && expr.type ? useHook(expr, coerce) : undefined;
-}
-function useEvalVisibilityHook(useEvalExpressionHook, definition, overrideDataNode) {
-  const dynamicVisibility = useEvalDynamicBoolHook(definition, DynamicPropertyType.Visible, useEvalExpressionHook);
-  return makeDynamicPropertyHook(dynamicVisibility, (ctx, {
-    definition,
-    overrideDataNode
-  }) => useComputed(() => {
-    const dataNode = overrideDataNode != null ? overrideDataNode : ctx.dataNode;
-    return !dataNode || matchesType(dataNode) && !hideDisplayOnly(dataNode, ctx.schemaInterface, definition);
-  }), {
-    definition,
-    overrideDataNode
-  });
-}
-function useEvalReadonlyHook(useEvalExpressionHook, definition) {
-  const dynamicReadonly = useEvalDynamicBoolHook(definition, DynamicPropertyType.Readonly, useEvalExpressionHook);
-  return makeDynamicPropertyHook(dynamicReadonly, (ctx, {
-    definition
-  }) => useCalculatedControl(() => isControlReadonly(definition)), {
-    definition
-  });
-}
-function useEvalStyleHook(useEvalExpressionHook, property, definition) {
-  const dynamicStyle = useEvalDynamicHook(definition, property, useEvalExpressionHook);
-  return makeDynamicPropertyHook(dynamicStyle, () => useControl(undefined), undefined);
-}
-function useEvalAllowedOptionsHook(useEvalExpressionHook, definition) {
-  const dynamicAllowed = useEvalDynamicHook(definition, DynamicPropertyType.AllowedOptions, useEvalExpressionHook);
-  return makeDynamicPropertyHook(dynamicAllowed, () => useControl([]), undefined);
-}
-function useEvalDisabledHook(useEvalExpressionHook, definition) {
-  const dynamicDisabled = useEvalDynamicBoolHook(definition, DynamicPropertyType.Disabled, useEvalExpressionHook);
-  return makeDynamicPropertyHook(dynamicDisabled, ctx => useComputed(() => {
-    var _ctx$dataNode, _dataControl$meta$nul;
-    const dataControl = (_ctx$dataNode = ctx.dataNode) == null ? void 0 : _ctx$dataNode.control;
-    const setToNull = (dataControl == null || (_dataControl$meta$nul = dataControl.meta["nullControl"]) == null ? void 0 : _dataControl$meta$nul.value) === false;
-    return setToNull || isControlDisabled(definition);
-  }), undefined);
-}
-function useEvalDisplayHook(useEvalExpressionHook, definition) {
-  return useEvalDynamicHook(definition, DynamicPropertyType.Display, useEvalExpressionHook);
-}
-function useEvalDefaultValueHook(useEvalExpressionHook, definition) {
-  const dynamicValue = useEvalDynamicHook(definition, DynamicPropertyType.DefaultValue, useEvalExpressionHook);
-  return makeDynamicPropertyHook(dynamicValue, (ctx, {
-    definition
-  }) => {
-    return useComputed(calcDefault);
-    function calcDefault() {
-      var _ctx$dataNode2;
-      const [required, dcv] = isDataControl(definition) ? [definition.required, definition.defaultValue] : [false, undefined];
-      const field = (_ctx$dataNode2 = ctx.dataNode) == null ? void 0 : _ctx$dataNode2.schema.field;
-      return dcv != null ? dcv : field ? ctx.dataNode.elementIndex != null ? elementValueForField(field) : defaultValueForField(field, required) : undefined;
-    }
-  }, {
-    definition
-  });
-}
-function useDataExpression(fvExpr, node, coerce = x => x) {
-  const otherField = schemaDataForFieldRef(fvExpr.field, node);
-  return useCalculatedControl(() => {
-    var _otherField$control;
-    return coerce((_otherField$control = otherField.control) == null ? void 0 : _otherField$control.value);
-  });
-}
-function useDataMatchExpression(fvExpr, node, coerce = x => x) {
-  const otherField = schemaDataForFieldRef(fvExpr.field, node);
-  return useCalculatedControl(() => {
-    var _otherField$control2;
-    const fv = (_otherField$control2 = otherField.control) == null ? void 0 : _otherField$control2.value;
-    return coerce(Array.isArray(fv) ? fv.includes(fvExpr.value) : fv === fvExpr.value);
-  });
-}
-function useNotEmptyExpression(fvExpr, node, schemaInterface, coerce = x => x) {
-  const otherField = schemaDataForFieldRef(fvExpr.field, node);
-  return useCalculatedControl(() => {
-    var _otherField$control3;
-    const fv = (_otherField$control3 = otherField.control) == null ? void 0 : _otherField$control3.value;
-    const field = otherField.schema.field;
-    return coerce(field && !schemaInterface.isEmptyValue(field, fv));
-  });
-}
-function defaultEvalHooks(expr, context, coerce) {
-  switch (expr.type) {
-    case ExpressionType.Jsonata:
-      const bindings = useComputed(() => ({
-        formData: context.formData
-      }));
-      return useJsonataExpression(expr.expression, getRootDataNode(context.parentNode).control, getJsonPath(context.parentNode), bindings, coerce);
-    case ExpressionType.UUID:
-      return useUuidExpression(coerce);
-    case ExpressionType.Data:
-      return useDataExpression(expr, context.parentNode, coerce);
-    case ExpressionType.DataMatch:
-      return useDataMatchExpression(expr, context.parentNode, coerce);
-    case ExpressionType.NotEmpty:
-      return useNotEmptyExpression(expr, context.parentNode, context.schemaInterface, coerce);
-    default:
-      return useControl(undefined);
-  }
-}
-const defaultUseEvalExpressionHook = makeEvalExpressionHook(defaultEvalHooks);
-function makeEvalExpressionHook(f) {
-  return (expr, coerce) => ({
-    deps: expr == null ? void 0 : expr.type,
-    state: expr && expr.type ? expr : undefined,
-    runHook: (ctx, state) => {
-      return state ? f(state, ctx, coerce) : undefined;
-    }
-  });
-}
-function useEvalDynamicBoolHook(definition, type, useEvalExpressionHook) {
-  return useEvalDynamicHook(definition, type, useEvalExpressionHook, x => Boolean(x));
-}
-function useEvalDynamicHook(definition, type, useEvalExpressionHook, coerce = x => x) {
-  var _definition$dynamic;
-  const expression = (_definition$dynamic = definition.dynamic) == null ? void 0 : _definition$dynamic.find(x => x.type === type);
-  return useEvalExpressionHook(expression == null ? void 0 : expression.expr, coerce);
-}
-function matchesType(context) {
-  const types = context.schema.field.onlyForTypes;
-  if (types == null || types.length === 0) return true;
-  const parent = context.parent;
-  const typeNode = parent.schema.getChildNodes().find(x => x.field.isTypeField);
-  if (typeNode == null) return true;
-  const typeField = parent.getChild(typeNode).control;
-  return typeField && types.includes(typeField.value);
-}
-function hideDisplayOnly(context, schemaInterface, definition) {
-  var _context$control;
-  const displayOptions = getDisplayOnlyOptions(definition);
-  return displayOptions && !displayOptions.emptyText && schemaInterface.isEmptyValue(context.schema.field, (_context$control = context.control) == null ? void 0 : _context$control.value);
-}
-function useUuidExpression(coerce = x => x) {
-  return useControl(() => coerce(v4()));
-}
-function useJsonataExpression(jExpr, data, path, bindings, coerce = x => x) {
-  const pathString = jsonPathString(path, x => `#$i[${x}]`);
-  const fullExpr = pathString ? pathString + ".(" + jExpr + ")" : jExpr;
-  const compiledExpr = useMemo(() => {
-    try {
-      return jsonata(jExpr ? fullExpr : "null");
-    } catch (e) {
-      console.error(e);
-      return jsonata("null");
-    }
-  }, [fullExpr]);
-  const control = useControl();
-  const listenerRef = useRef();
-  const updateRef = useRef(0);
-  const [ref] = useRefState(() => new SubscriptionTracker(() => {
-    const l = listenerRef.current;
-    if (l) {
-      listenerRef.current = undefined;
-      addAfterChangesCallback(() => {
-        listenerRef.current = l;
-        l();
-      });
-    }
-  }));
-  useEffect(() => {
-    listenerRef.current = apply;
-    apply();
-    async function apply() {
-      const tracker = ref.current;
-      try {
-        updateRef.current++;
-        control.value = coerce(await compiledExpr.evaluate(trackedValue(data, tracker.collectUsage), collectChanges(tracker.collectUsage, () => bindings == null ? void 0 : bindings.value)));
-      } finally {
-        if (! --updateRef.current) tracker.update();
-      }
-    }
-  }, [compiledExpr]);
-  useEffect(() => {
-    return () => {
-      listenerRef.current = undefined;
-      ref.current.cleanup();
-    };
-  }, []);
-  return control;
-}
-function useEvalActionHook(useExpr, definition) {
-  const dynamicValue = useEvalDynamicHook(definition, DynamicPropertyType.ActionData, useExpr);
-  return makeDynamicPropertyHook(dynamicValue, () => useControl(null), undefined);
-}
-function useEvalLabelText(useExpr, definition) {
-  const dynamicValue = useEvalDynamicHook(definition, DynamicPropertyType.Label, useExpr);
-  return makeDynamicPropertyHook(dynamicValue, () => useControl(null), undefined);
-}
-function makeDynamicPropertyHook(dynamicValue, makeDefault, state, deps) {
-  return {
-    deps: deps === undefined ? dynamicValue.deps : [deps, dynamicValue.deps].map(toDepString).join(),
-    runHook: (ctx, s) => {
-      var _dynamicValue$runHook, _dynamicValue$runHook2;
-      return (_dynamicValue$runHook = (_dynamicValue$runHook2 = dynamicValue.runHook(ctx, s[0])) == null ? void 0 : _dynamicValue$runHook2.as()) != null ? _dynamicValue$runHook : makeDefault(ctx, s[1]);
-    },
-    state: [dynamicValue.state, state]
-  };
-}
-
-function useMakeValidationHook(definition, useValidatorFor = useDefaultValidator) {
-  var _dd$validators;
-  const dd = isDataControl(definition) ? definition : undefined;
-  const refData = useUpdatedRef({
-    dd,
-    useValidatorFor
-  });
-  const depString = dd ? makeHookDepString((_dd$validators = dd.validators) != null ? _dd$validators : [], x => x.type) : "~";
-  return useCallback(ctx => {
-    var _ctx$dataContext$data, _ctx$dataContext$data2, _dd$validators2;
-    const {
-      dd
-    } = refData.current;
-    if (!dd) return;
-    const field = (_ctx$dataContext$data = (_ctx$dataContext$data2 = ctx.dataContext.dataNode) == null ? void 0 : _ctx$dataContext$data2.schema.field) != null ? _ctx$dataContext$data : {
-      field: "__missing",
-      type: FieldType.Any
-    };
-    const {
-      control,
-      hiddenControl,
-      dataContext: {
-        schemaInterface
-      }
-    } = ctx;
-    useValueChangeEffect(control, () => control.setError("default", ""));
-    if (dd.required) useValidator(control, v => {
-      return !hiddenControl.value && schemaInterface.isEmptyValue(field, v) ? schemaInterface.validationMessageText(field, ValidationMessageType.NotEmpty, false, true) : null;
-    }, "required");
-    (_dd$validators2 = dd.validators) == null || _dd$validators2.forEach((v, i) => useValidatorFor(v, _extends({}, ctx, {
-      index: i,
-      field,
-      definition: dd
-    })));
-  }, [!!dd, dd == null ? void 0 : dd.required, depString, useValidatorFor]);
-}
-function useDefaultValidator(validator, ctx) {
-  switch (validator.type) {
-    case ValidatorType.Length:
-      useLengthValidator(validator, ctx);
-      break;
-    case ValidatorType.Jsonata:
-      useJsonataValidator(validator, ctx);
-      break;
-    case ValidatorType.Date:
-      useDateValidator(validator, ctx);
-      break;
-  }
-}
-function useJsonataValidator(validator, ctx) {
-  const sdn = ctx.dataContext.parentNode;
-  const errorMsg = useJsonataExpression(validator.expression, getRootDataNode(sdn).control, getJsonPath(sdn), undefined, v => v == null ? null : typeof v === "string" ? v : JSON.stringify(v));
-  useValidator(ctx.control, () => !ctx.hiddenControl.value ? errorMsg.value : null, "jsonata" + ctx.index);
-}
-function useLengthValidator(lv, ctx) {
-  const {
-    control,
-    dataContext: {
-      schemaInterface
-    },
-    hiddenControl,
-    field
-  } = ctx;
-  useValidator(control, v => {
-    const len = schemaInterface.controlLength(field, control);
-    const hidden = hiddenControl.value;
-    if (hidden) {
-      return undefined;
-    }
-    if (lv.min != null && len < lv.min) {
-      if (field != null && field.collection) {
-        control.setValue(v => Array.isArray(v) ? v.concat(Array.from({
-          length: lv.min - v.length
-        })) : Array.from({
-          length: lv.min
-        }));
-      } else {
-        return schemaInterface.validationMessageText(field, ValidationMessageType.MinLength, len, lv.min);
-      }
-    } else if (lv.max != null && len > lv.max) {
-      return schemaInterface.validationMessageText(field, ValidationMessageType.MaxLength, len, lv.max);
-    }
-    return undefined;
-  }, "length" + ctx.index);
-}
-function useDateValidator(dv, ctx) {
-  const {
-    control,
-    field,
-    index,
-    dataContext: {
-      schemaInterface
-    }
-  } = ctx;
-  let comparisonDate;
-  if (dv.fixedDate) {
-    comparisonDate = schemaInterface.parseToMillis(field, dv.fixedDate);
-  } else {
-    const nowDate = new Date();
-    comparisonDate = Date.UTC(nowDate.getFullYear(), nowDate.getMonth(), nowDate.getDate());
-    if (dv.daysFromCurrent) {
-      comparisonDate += dv.daysFromCurrent * 86400000;
-    }
-  }
-  useValidator(control, v => {
-    if (v) {
-      const selDate = schemaInterface.parseToMillis(field, v);
-      const notAfter = dv.comparison === DateComparison.NotAfter;
-      if (notAfter ? selDate > comparisonDate : selDate < comparisonDate) {
-        return schemaInterface.validationMessageText(field, notAfter ? ValidationMessageType.NotAfterDate : ValidationMessageType.NotBeforeDate, selDate, comparisonDate);
-      }
-    }
-    return null;
-  }, "date" + index);
-}
-
-class DefaultSchemaInterface {
-  constructor(boolStrings = ["No", "Yes"], parseDateTime = s => Date.parse(s)) {
-    this.boolStrings = void 0;
-    this.parseDateTime = void 0;
-    this.boolStrings = boolStrings;
-    this.parseDateTime = parseDateTime;
-  }
-  parseToMillis(field, v) {
-    return this.parseDateTime(v);
-  }
-  validationMessageText(field, messageType, actual, expected) {
-    switch (messageType) {
-      case ValidationMessageType.NotEmpty:
-        return "Please enter a value";
-      case ValidationMessageType.MinLength:
-        return "Length must be at least " + expected;
-      case ValidationMessageType.MaxLength:
-        return "Length must be less than " + expected;
-      case ValidationMessageType.NotBeforeDate:
-        return `Date must not be before ${new Date(expected).toDateString()}`;
-      case ValidationMessageType.NotAfterDate:
-        return `Date must not be after ${new Date(expected).toDateString()}`;
-      default:
-        return "Unknown error";
-    }
-  }
-  getDataOptions(node) {
-    return this.getNodeOptions(node.schema);
-  }
-  getNodeOptions(node) {
-    return this.getOptions(node.field);
-  }
-  getOptions({
-    options
-  }) {
-    return options && options.length > 0 ? options : null;
-  }
-  getFilterOptions(array, field) {
-    return this.getNodeOptions(field);
-  }
-  isEmptyValue(f, value) {
-    if (f.collection) return Array.isArray(value) ? value.length === 0 : value == null;
-    switch (f.type) {
-      case FieldType.String:
-      case FieldType.DateTime:
-      case FieldType.Date:
-      case FieldType.Time:
-        return !value;
-      default:
-        return value == null;
-    }
-  }
-  searchText(field, value) {
-    var _this$textValue$toLow, _this$textValue;
-    return (_this$textValue$toLow = (_this$textValue = this.textValue(field, value)) == null ? void 0 : _this$textValue.toLowerCase()) != null ? _this$textValue$toLow : "";
-  }
-  textValue(field, value, element) {
-    const options = this.getOptions(field);
-    const option = options == null ? void 0 : options.find(x => x.value === value);
-    if (option) return option.name;
-    switch (field.type) {
-      case FieldType.Date:
-        return value ? new Date(value).toLocaleDateString() : undefined;
-      case FieldType.DateTime:
-        return value ? new Date(this.parseToMillis(field, value)).toLocaleString() : undefined;
-      case FieldType.Time:
-        return value ? new Date("1970-01-01T" + value).toLocaleTimeString() : undefined;
-      case FieldType.Bool:
-        return this.boolStrings[value ? 1 : 0];
-      default:
-        return value != null ? value.toString() : undefined;
-    }
-  }
-  controlLength(f, control) {
-    var _control$elements$len, _control$elements;
-    return f.collection ? (_control$elements$len = (_control$elements = control.elements) == null ? void 0 : _control$elements.length) != null ? _control$elements$len : 0 : this.valueLength(f, control.value);
-  }
-  valueLength(field, value) {
-    var _ref;
-    return (_ref = value && (value == null ? void 0 : value.length)) != null ? _ref : 0;
-  }
-  compareValue(field, v1, v2) {
-    if (v1 == null) return v2 == null ? 0 : 1;
-    if (v2 == null) return -1;
-    switch (field.type) {
-      case FieldType.Date:
-      case FieldType.DateTime:
-      case FieldType.Time:
-      case FieldType.String:
-        return v1.localeCompare(v2);
-      case FieldType.Bool:
-        return v1 ? v2 ? 0 : 1 : -1;
-      case FieldType.Int:
-      case FieldType.Double:
-        return v1 - v2;
-      default:
-        return 0;
-    }
-  }
-  compoundFieldSetup(f) {
-    return f.getChildNodes().map(x => {
-      const {
-        field
-      } = x.field;
-      return [field, this.makeControlSetup(x)];
-    });
-  }
-  compoundFieldEquality(f) {
-    return f.getChildNodes().map(x => {
-      const {
-        field
-      } = x.field;
-      return [field, (a, b) => this.makeEqualityFunc(x)(a[field], b[field])];
-    });
-  }
-  makeEqualityFunc(field, element) {
-    if (field.field.collection && !element) {
-      const elemEqual = this.makeEqualityFunc(field, true);
-      return (a, b) => {
-        if (a === b) return true;
-        if (a == null || b == null) return false;
-        if (a.length !== b.length) return false;
-        for (let i = 0; i < a.length; i++) {
-          if (!elemEqual(a[i], b[i])) return false;
-        }
-        return true;
-      };
-    }
-    switch (field.field.type) {
-      case FieldType.Compound:
-        const allChecks = this.compoundFieldEquality(field);
-        return (a, b) => a === b || a != null && b != null && allChecks.every(x => x[1](a, b));
-      default:
-        return (a, b) => a === b;
-    }
-  }
-  makeControlSetup(field, element) {
-    let setup = {
-      equals: this.makeEqualityFunc(field, element)
-    };
-    if (field.field.collection && !element) {
-      setup.elems = this.makeControlSetup(field, true);
-      return setup;
-    }
-    switch (field.field.type) {
-      case FieldType.Compound:
-        setup.fields = Object.fromEntries(this.compoundFieldSetup(field));
-    }
-    return setup;
-  }
-}
-const defaultSchemaInterface = new DefaultSchemaInterface();
-
-const _excluded = ["styleClass", "labelClass", "layoutClass"],
-  _excluded2 = ["parentDataNode"],
-  _excluded3 = ["definition", "control", "formOptions", "style", "allowedOptions", "schemaInterface", "styleClass"];
+const _excluded$1 = ["formOptions", "style", "allowedOptions", "schemaInterface", "styleClass", "textClass", "displayOnly", "inline"];
 const AppendAdornmentPriority = 0;
 const WrapAdornmentPriority = 1000;
 /**
@@ -2158,258 +889,26 @@ var LabelType;
    */
   LabelType[LabelType["Text"] = 2] = "Text";
 })(LabelType || (LabelType = {}));
-function useControlRenderer(definition, fields, renderer, options = {}) {
-  const r = useUpdatedRef({
-    definition,
-    fields,
-    renderer,
-    options
-  });
-  return useCallback(({
-    control,
-    parentPath
-  }) => {
-    return /*#__PURE__*/jsx(ControlRenderer, _extends({}, r.current, {
-      control: control,
-      parentPath: parentPath
-    }));
-  }, [r]);
-}
-function useControlRendererComponent(controlOrFormNode, renderer, options = {}, parentDataNode) {
-  var _options$useDataHook, _options$schemaInterf, _options$useEvalExpre;
-  const [definition, formNode] = "definition" in controlOrFormNode ? [controlOrFormNode.definition, controlOrFormNode] : [controlOrFormNode, legacyFormNode(controlOrFormNode)];
-  const dataProps = (_options$useDataHook = options.useDataHook == null ? void 0 : options.useDataHook(definition)) != null ? _options$useDataHook : defaultDataProps;
-  const elementIndex = options.elementIndex;
-  const schemaInterface = (_options$schemaInterf = options.schemaInterface) != null ? _options$schemaInterf : defaultSchemaInterface;
-  const useExpr = (_options$useEvalExpre = options.useEvalExpressionHook) != null ? _options$useEvalExpre : defaultUseEvalExpressionHook;
-  let dataNode;
-  if (elementIndex != null) {
-    dataNode = parentDataNode.getChildElement(elementIndex);
-  } else {
-    dataNode = lookupDataNode(definition, parentDataNode);
-  }
-  const useValidation = useMakeValidationHook(definition, options.useValidationHook);
-  const dynamicHooks = useDynamicHooks({
-    defaultValueControl: useEvalDefaultValueHook(useExpr, definition),
-    visibleControl: useEvalVisibilityHook(useExpr, definition),
-    readonlyControl: useEvalReadonlyHook(useExpr, definition),
-    disabledControl: useEvalDisabledHook(useExpr, definition),
-    allowedOptions: useEvalAllowedOptionsHook(useExpr, definition),
-    labelText: useEvalLabelText(useExpr, definition),
-    actionData: useEvalActionHook(useExpr, definition),
-    customStyle: useEvalStyleHook(useExpr, DynamicPropertyType.Style, definition),
-    layoutStyle: useEvalStyleHook(useExpr, DynamicPropertyType.LayoutStyle, definition),
-    displayControl: useEvalDisplayHook(useExpr, definition)
-  });
-  const r = useUpdatedRef({
-    options,
-    definition,
-    elementIndex,
-    parentDataNode,
-    dataNode,
-    formNode
-  });
-  if (formNode == null) debugger;
-  const Component = useCallback(() => {
-    const stopTracking = useComponentTracking();
-    try {
-      var _options$formData, _dataNode, _definition$adornment2, _definition$adornment3, _formNode$tree$getByR, _options$adjustLayout;
-      const {
-        definition: c,
-        options,
-        elementIndex,
-        parentDataNode: pdn,
-        dataNode: dn,
-        formNode
-      } = r.current;
-      const formData = (_options$formData = options.formData) != null ? _options$formData : {};
-      const dataContext = {
-        schemaInterface,
-        dataNode: dn,
-        parentNode: pdn,
-        formData
-      };
-      const {
-        readonlyControl,
-        disabledControl,
-        visibleControl,
-        displayControl,
-        layoutStyle,
-        labelText,
-        customStyle,
-        allowedOptions,
-        defaultValueControl,
-        actionData
-      } = dynamicHooks(dataContext);
-      const visible = visibleControl.current.value;
-      const visibility = useControl(() => visible != null ? {
-        visible,
-        showing: visible
-      } : undefined);
-      useControlEffect(() => visibleControl.value, visible => {
-        if (visible != null) visibility.setValue(ex => ({
-          visible,
-          showing: ex ? ex.showing : visible
-        }));
-      });
-      const parentControl = parentDataNode.control;
-      const control = (_dataNode = dataNode) == null ? void 0 : _dataNode.control;
-      useControlEffect(() => {
-        var _definition$adornment, _definition$renderOpt;
-        return [visibility.value, defaultValueControl.value, control == null ? void 0 : control.isNull, isDataControl(definition) && definition.dontClearHidden, ((_definition$adornment = definition.adornments) == null ? void 0 : _definition$adornment.some(x => x.type === ControlAdornmentType.Optional)) || isDataControl(definition) && ((_definition$renderOpt = definition.renderOptions) == null ? void 0 : _definition$renderOpt.type) == DataRenderType.NullToggle, parentControl.isNull, options.hidden, readonlyControl.value];
-      }, ([vc, dv, _, dontClear, dontDefault, parentNull, hidden, ro]) => {
-        if (!ro) {
-          if (control) {
-            if (vc && vc.visible === vc.showing) {
-              if (hidden || !vc.visible) {
-                control.setValue(x => options.clearHidden && !dontClear ? undefined : x == null && dontClear && !dontDefault ? dv : x);
-              } else if (!dontDefault) control.setValue(x => x != null ? x : dv);
-            }
-          } else if (parentNull) {
-            parentControl.setValue(x => x != null ? x : {});
-          }
-        }
-      }, true);
-      const myOptionsControl = useComputed(() => {
-        var _visibility$fields;
-        return {
-          hidden: options.hidden || !((_visibility$fields = visibility.fields) != null && _visibility$fields.showing.value),
-          readonly: options.readonly || readonlyControl.value,
-          disabled: options.disabled || disabledControl.value,
-          displayOnly: options.displayOnly || isControlDisplayOnly(c)
-        };
-      });
-      const myOptions = trackedValue(myOptionsControl);
-      useValidation({
-        control: control != null ? control : newControl(null),
-        hiddenControl: myOptionsControl.fields.hidden,
-        dataContext
-      });
-      const inheritableOptions = _objectWithoutPropertiesLoose(options, _excluded);
-      const childOptions = _extends({}, inheritableOptions, myOptions, {
-        elementIndex: undefined
-      });
-      useEffect(() => {
-        if (control && typeof myOptions.disabled === "boolean" && control.disabled != myOptions.disabled) control.disabled = myOptions.disabled;
-      }, [control, myOptions.disabled]);
-      if (parentControl.isNull) return /*#__PURE__*/jsx(Fragment, {});
-      const adornments = (_definition$adornment2 = (_definition$adornment3 = definition.adornments) == null ? void 0 : _definition$adornment3.map(x => renderer.renderAdornment({
-        adornment: x,
-        dataContext,
-        useExpr,
-        formOptions: myOptions
-      }))) != null ? _definition$adornment2 : [];
-      const otherChildNodes = definition.childRefId && ((_formNode$tree$getByR = formNode.tree.getByRefId(definition.childRefId)) == null ? void 0 : _formNode$tree$getByR.getChildNodes());
-      const labelAndChildren = renderControlLayout({
-        formNode: otherChildNodes ? formNode.tree.createTempNode(formNode.id, definition, otherChildNodes) : formNode,
-        definition: c,
-        renderer,
-        renderChild: (k, child, options) => {
-          var _ref2;
-          const overrideClasses = getGroupClassOverrides(c);
-          const _ref = options != null ? options : {},
-            {
-              parentDataNode
-            } = _ref,
-            renderOptions = _objectWithoutPropertiesLoose(_ref, _excluded2);
-          const dContext = (_ref2 = parentDataNode != null ? parentDataNode : dataContext.dataNode) != null ? _ref2 : dataContext.parentNode;
-          const allChildOptions = _extends({}, childOptions, overrideClasses, renderOptions);
-          return /*#__PURE__*/jsx(NewControlRenderer, {
-            definition: child,
-            renderer: renderer,
-            parentDataNode: dContext,
-            options: allChildOptions
-          }, k);
-        },
-        createDataProps: dataProps,
-        formOptions: myOptions,
-        dataContext,
-        control: displayControl != null ? displayControl : control,
-        elementIndex,
-        schemaInterface,
-        labelText,
-        displayControl,
-        style: customStyle.value,
-        allowedOptions,
-        customDisplay: options.customDisplay,
-        actionDataControl: actionData,
-        actionOnClick: options.actionOnClick,
-        styleClass: options.styleClass,
-        labelClass: options.labelClass,
-        useEvalExpression: useExpr,
-        useChildVisibility: (childDef, parentNode, dontOverride) => {
-          var _ref3;
-          return useEvalVisibilityHook(useExpr, childDef, !dontOverride ? lookupDataNode(childDef, (_ref3 = parentNode != null ? parentNode : dataNode) != null ? _ref3 : parentDataNode) : undefined);
-        }
-      });
-      const layoutProps = _extends({}, labelAndChildren, {
-        adornments,
-        className: rendererClass(options.layoutClass, c.layoutClass),
-        style: layoutStyle.value
-      });
-      const renderedControl = renderer.renderLayout((_options$adjustLayout = options.adjustLayout == null ? void 0 : options.adjustLayout(dataContext, layoutProps)) != null ? _options$adjustLayout : layoutProps);
-      return renderer.renderVisibility(_extends({
-        visibility
-      }, renderedControl));
-    } finally {
-      stopTracking();
-    }
-  }, [r, dataProps, useValidation, renderer, schemaInterface, dynamicHooks]);
-  Component.displayName = "RenderControl";
-  return Component;
-}
-function ControlRenderer({
-  definition,
-  fields,
-  renderer,
-  options,
-  control,
-  parentPath
-}) {
-  var _effect = useComponentTracking();
-  try {
-    const schemaDataNode = makeSchemaDataNode(createSchemaLookup({
-      "": fields
-    }).getSchema(""), control);
-    const Render = useControlRendererComponent(definition, renderer, options, schemaDataNode);
-    return /*#__PURE__*/jsx(Render, {});
-  } finally {
-    _effect();
-  }
-}
-function NewControlRenderer({
-  definition,
-  renderer,
-  options,
-  parentDataNode
-}) {
-  var _effect2 = useComponentTracking();
-  try {
-    const Render = useControlRendererComponent(definition, renderer, options, parentDataNode);
-    return /*#__PURE__*/jsx(Render, {});
-  } finally {
-    _effect2();
-  }
-}
-function defaultDataProps(_ref4) {
-  var _allowedOptions$value, _definition$renderOpt2;
+function defaultDataProps(_ref, definition, control) {
+  var _definition$renderOpt;
   let {
-      definition,
-      control,
       formOptions,
       style,
       allowedOptions,
       schemaInterface = defaultSchemaInterface,
-      styleClass
-    } = _ref4,
-    props = _objectWithoutPropertiesLoose(_ref4, _excluded3);
+      styleClass,
+      textClass: tc,
+      displayOnly,
+      inline
+    } = _ref,
+    props = _objectWithoutPropertiesLoose(_ref, _excluded$1);
   const dataNode = props.dataContext.dataNode;
   const field = dataNode.schema.field;
   const className = rendererClass(styleClass, definition.styleClass);
-  const displayOnly = !!formOptions.displayOnly;
+  const textClass = rendererClass(tc, definition.textClass);
   const required = !!definition.required && !displayOnly;
   const fieldOptions = schemaInterface.getDataOptions(dataNode);
-  const _allowed = (_allowedOptions$value = allowedOptions == null ? void 0 : allowedOptions.value) != null ? _allowedOptions$value : [];
+  const _allowed = allowedOptions != null ? allowedOptions : [];
   const allowed = Array.isArray(_allowed) ? _allowed : [_allowed];
   return _extends({
     dataNode,
@@ -2417,6 +916,7 @@ function defaultDataProps(_ref4) {
     control,
     field,
     id: "c" + control.uniqueId,
+    inline: !!inline,
     options: allowed.length > 0 ? allowed.map(x => {
       var _fieldOptions$find;
       return typeof x === "object" ? x : (_fieldOptions$find = fieldOptions == null ? void 0 : fieldOptions.find(y => y.value == x)) != null ? _fieldOptions$find : {
@@ -2425,40 +925,46 @@ function defaultDataProps(_ref4) {
       };
     }).filter(x => x != null) : fieldOptions,
     readonly: !!formOptions.readonly,
-    displayOnly,
-    renderOptions: (_definition$renderOpt2 = definition.renderOptions) != null ? _definition$renderOpt2 : {
+    displayOnly: !!displayOnly,
+    renderOptions: (_definition$renderOpt = definition.renderOptions) != null ? _definition$renderOpt : {
       type: "Standard"
     },
     required,
     hidden: !!formOptions.hidden,
     className,
+    textClass,
     style
   }, props);
 }
 function renderControlLayout(props) {
   const {
-    definition: c,
     renderer,
     renderChild,
     control,
     dataContext,
     createDataProps: dataProps,
-    displayControl,
     style,
-    labelText,
-    useChildVisibility,
     designMode,
     customDisplay,
-    useEvalExpression,
+    runExpression,
     labelClass,
+    labelTextClass,
     styleClass,
-    formNode
+    textClass,
+    formNode,
+    formOptions,
+    actionOnClick,
+    state,
+    getChildState,
+    inline,
+    displayOnly
   } = props;
+  const c = state.definition;
   if (isDataControl(c)) {
     return renderData(c);
   }
   if (isGroupControl(c)) {
-    var _c$groupOptions2, _labelText$value, _c$groupOptions3;
+    var _c$groupOptions2, _c$groupOptions3;
     if (c.compoundField) {
       var _c$groupOptions;
       return renderData(dataControl(c.compoundField, c.title, {
@@ -2467,41 +973,68 @@ function renderControlLayout(props) {
       }));
     }
     return {
+      inline,
       processLayout: renderer.renderGroup({
         formNode,
+        state,
         definition: c,
         renderChild,
-        useEvalExpression,
+        runExpression,
         dataContext,
         renderOptions: (_c$groupOptions2 = c.groupOptions) != null ? _c$groupOptions2 : {
           type: "Standard"
         },
         className: rendererClass(styleClass, c.styleClass),
-        useChildVisibility,
+        textClass: rendererClass(textClass, c.textClass),
         style,
-        designMode
+        designMode,
+        actionOnClick,
+        getChildState
       }),
       label: {
-        label: (_labelText$value = labelText == null ? void 0 : labelText.value) != null ? _labelText$value : c.title,
+        label: c.title,
         className: rendererClass(labelClass, c.labelClass),
+        textClass: rendererClass(labelTextClass, c.labelTextClass),
         type: LabelType.Group,
         hide: (_c$groupOptions3 = c.groupOptions) == null ? void 0 : _c$groupOptions3.hideTitle
       }
     };
   }
   if (isActionControl(c)) {
-    var _props$actionDataCont, _props$actionDataCont2, _ref5, _labelText$value2, _props$actionOnClick;
-    const actionData = (_props$actionDataCont = (_props$actionDataCont2 = props.actionDataControl) == null ? void 0 : _props$actionDataCont2.value) != null ? _props$actionDataCont : c.actionData;
+    var _c$actionStyle, _c$title, _props$actionOnClick;
+    const actionData = c.actionData;
+    const actionStyle = (_c$actionStyle = c.actionStyle) != null ? _c$actionStyle : ActionStyle.Button;
+    const actionContent = actionStyle == ActionStyle.Group ? renderActionGroup() : undefined;
     return {
+      inline,
       children: renderer.renderAction({
-        actionText: (_ref5 = (_labelText$value2 = labelText == null ? void 0 : labelText.value) != null ? _labelText$value2 : c.title) != null ? _ref5 : c.actionId,
+        actionText: (_c$title = c.title) != null ? _c$title : c.actionId,
         actionId: c.actionId,
         actionData,
+        actionContent,
+        actionStyle,
+        textClass: rendererClass(textClass, c.textClass),
+        iconPlacement: c.iconPlacement,
+        icon: c.icon,
+        inline,
         onClick: (_props$actionOnClick = props.actionOnClick == null ? void 0 : props.actionOnClick(c.actionId, actionData, dataContext)) != null ? _props$actionOnClick : () => {},
         className: rendererClass(styleClass, c.styleClass),
         style
       })
     };
+    function renderActionGroup() {
+      const childDefs = formNode.getResolvedChildren();
+      const childDef = {
+        type: ControlDefinitionType.Group,
+        groupOptions: {
+          type: GroupRenderType.Contents,
+          hideTitle: true
+        },
+        children: childDefs
+      };
+      const childNode = formNode.createChildNode("child", childDef);
+      return renderChild("child", childNode, {});
+    }
   }
   if (isDisplayControl(c)) {
     var _c$displayData;
@@ -2509,36 +1042,41 @@ function renderControlLayout(props) {
     const displayProps = {
       data,
       className: rendererClass(styleClass, c.styleClass),
+      textClass: rendererClass(textClass, c.textClass),
       style,
-      display: displayControl,
-      dataContext
+      dataContext,
+      inline
     };
     if (data.type === DisplayDataType.Custom && customDisplay) {
       return {
+        inline,
         children: customDisplay(data.customId, displayProps)
       };
     }
     return {
+      inline,
       children: renderer.renderDisplay(displayProps)
     };
   }
   return {};
   function renderData(c) {
-    var _labelText$value3, _c$children$length, _c$children;
+    var _c$children$length, _c$children;
     if (!control) return {
       children: "No control for: " + c.field
     };
-    const rendererProps = dataProps(props);
-    const label = !c.hideTitle ? controlTitle((_labelText$value3 = labelText == null ? void 0 : labelText.value) != null ? _labelText$value3 : c.title, props.dataContext.dataNode.schema.field) : undefined;
+    const rendererProps = dataProps(props, c, control);
+    const label = !c.hideTitle ? controlTitle(c.title, props.dataContext.dataNode.schema.field) : undefined;
     return {
+      inline,
       processLayout: renderer.renderData(rendererProps),
       label: {
         type: ((_c$children$length = (_c$children = c.children) == null ? void 0 : _c$children.length) != null ? _c$children$length : 0) > 0 ? LabelType.Group : LabelType.Control,
         label,
         forId: rendererProps.id,
-        required: c.required && !props.formOptions.displayOnly,
+        required: c.required && !displayOnly,
         hide: c.hideTitle,
-        className: rendererClass(labelClass, c.labelClass)
+        className: rendererClass(labelClass, c.labelClass),
+        textClass: rendererClass(labelTextClass, c.labelTextClass)
       },
       errorControl: control
     };
@@ -2584,13 +1122,15 @@ function renderLayoutParts(props, renderer) {
     style,
     errorControl,
     label,
-    adornments
+    adornments,
+    inline
   } = (_props$processLayout = props.processLayout == null ? void 0 : props.processLayout(props)) != null ? _props$processLayout : props;
   const layout = {
     children,
     errorControl,
     style,
     className: className,
+    inline,
     wrapLayout: x => x
   };
   (adornments != null ? adornments : []).sort((a, b) => a.priority - b.priority).forEach(x => x.apply(layout));
@@ -2716,17 +1256,29 @@ function applyArrayLengthRestrictions({
   };
 }
 function fieldOptionAdornment(p) {
-  return (o, i, selected) => /*#__PURE__*/jsx(RenderArrayElements, {
+  return (o, fieldIndex, selected) => /*#__PURE__*/jsx(RenderArrayElements, {
     array: p.formNode.getChildNodes(),
     children: (cd, i) => p.renderChild(i, cd, {
       parentDataNode: p.dataContext.parentNode,
-      formData: {
-        option: o,
-        optionSelected: selected
+      stateKey: fieldIndex.toString(),
+      variables: {
+        formData: {
+          option: o,
+          optionSelected: selected
+        }
       }
     })
   });
 }
+function lookupChildDataContext(dataContext, c) {
+  var _dataContext$dataNode;
+  const parentNode = (_dataContext$dataNode = dataContext.dataNode) != null ? _dataContext$dataNode : dataContext.parentNode;
+  const dataNode = lookupDataNode(c, parentNode);
+  return _extends({}, dataContext, {
+    parentNode,
+    dataNode
+  });
+}
 
 function isIconAdornment(a) {
   return a.type === ControlAdornmentType.Icon;
@@ -2820,7 +1372,6 @@ function createFormRenderer(customRenderers = [], defaultRenderers) {
     renderLayout,
     renderVisibility,
     renderLabelText,
-    renderText: defaultRenderers.renderText,
     html: defaultRenderers.html
   };
   function renderVisibility(props) {
@@ -2868,7 +1419,7 @@ function createFormRenderer(customRenderers = [], defaultRenderers) {
       var _x$collection, _field$collection, _x$options;
       const noMatch = x.match ? !x.match(props, renderOptions) : undefined;
       if (noMatch === true) return false;
-      const matchCollection = ((_x$collection = x.collection) != null ? _x$collection : false) === (props.elementIndex == null && ((_field$collection = field.collection) != null ? _field$collection : false));
+      const matchCollection = ((_x$collection = x.collection) != null ? _x$collection : false) === (props.dataNode.elementIndex == null && ((_field$collection = field.collection) != null ? _field$collection : false));
       const isSchemaAllowed = !!x.schemaType && renderType == DataRenderType.Standard ? isOneOf(x.schemaType, field.type) : undefined;
       const isRendererAllowed = !!x.renderType && isOneOf(x.renderType, renderType);
       return matchCollection && ((_x$options = x.options) != null ? _x$options : false) === options && (isSchemaAllowed || isRendererAllowed || !x.renderType && !x.schemaType && noMatch === false);
@@ -2928,5 +1479,217 @@ function isArrayRegistration(x) {
   return x.type === "array";
 }
 
-export { AdornmentPlacement, AppendAdornmentPriority, ControlAdornmentType, ControlDefinitionType, ControlRenderer, DataRenderType, DateComparison, DefaultSchemaInterface, DisplayDataType, DynamicPropertyType, ExpressionType, FieldType, FormTree, GroupRenderType, LabelType, NewControlRenderer, SchemaTags, SyncTextType, ValidationMessageType, ValidatorType, WrapAdornmentPriority, accordionOptions, actionControl, actionHandlers, addFieldOption, addMissingControls, addMissingControlsForSchema, addMissingControlsToForm, adornmentOptions, appendMarkup, appendMarkupAt, applyArrayLengthRestrictions, applyDefaultForField, applyDefaultValues, applyExtensionToSchema, applyExtensionsToSchema, applyLengthRestrictions, applyValues, autocompleteOptions, boolField, buildSchema, checkListOptions, cleanDataForSchema, coerceToString, collectDifferences, compoundControl, compoundField, controlTitle, createAction, createActionRenderer, createAdornmentRenderer, createArrayActions, createArrayRenderer, createDataRenderer, createDisplayRenderer, createFormLookup, createFormRenderer, createFormTree, createGroupRenderer, createLabelRenderer, createLayoutRenderer, createSchemaLookup, createVisibilityRenderer, dataControl, dateField, dateTimeField, dateValidatorOptions, deepMerge, defaultCompoundField, defaultControlForField, defaultDataProps, defaultEvalHooks, defaultScalarField, defaultSchemaInterface, defaultUseEvalExpressionHook, defaultValueForField, defaultValueForFields, displayOnlyOptions, doubleField, dynamicDefaultValue, dynamicDisabled, dynamicReadonly, dynamicVisibility, elementValueForField, emptyGroupDefinition, fieldDisplayName, fieldEqExpr, fieldExpr, fieldHasTag, fieldOptionAdornment, fieldPathForDefinition, findChildDefinition, findCompoundField, findControlsForCompound, findField, findFieldPath, findNonDataGroups, findScalarField, getAllReferencedClasses, getAllValues, getDiffObject, getDisplayOnlyOptions, getExternalEditData, getGroupClassOverrides, getGroupRendererOptions, getIsEditing, getJsonPath, getLastDefinedValue, getLengthRestrictions, getNullToggler, getOverrideClass, getRootDataNode, getSchemaFieldList, getSchemaNodePath, getSchemaPath, getTagParam, groupedControl, hasOptions, hideDisplayOnly, htmlDisplayControl, intField, isAccordionAdornment, isActionControl, isArrayRenderer, isAutoCompleteClasses, isAutocompleteRenderer, isCheckEntryClasses, isCompoundField, isCompoundNode, isControlDisabled, isControlDisplayOnly, isControlReadonly, isDataControl, isDataGroupRenderer, isDateTimeRenderer, isDisplayControl, isDisplayOnlyRenderer, isFlexRenderer, isGridRenderer, isGroupControl, isIconAdornment, isOptionalAdornment, isScalarField, isSelectChildRenderer, isSetFieldAdornment, isTabsRenderer, isTextfieldRenderer, jsonPathString, jsonataExpr, jsonataOptions, jsonataValidatorOptions, layoutKeyForPlacement, legacyFormNode, lengthValidatorOptions, lookupDataNode, makeCompoundField, makeEvalExpressionHook, makeHook, makeHookDepString, makeParamTag, makeScalarField, makeSchemaDataNode, matchesType, mergeField, mergeFields, mergeObjects, optionalHook, radioButtonOptions, relativePath, renderControlLayout, renderLayoutParts, renderOptionsFor, rendererClass, resolveSchemas, rootSchemaNode, schemaDataForFieldPath, schemaDataForFieldRef, schemaForFieldPath, schemaForFieldRef, stringField, stringOptionsField, textDisplayControl, textfieldOptions, timeField, toDepString, traverseData, traverseParents, traverseSchemaPath, useControlDefinitionForSchema, useControlRenderer, useControlRendererComponent, useDateValidator, useDynamicHooks, useEvalActionHook, useEvalAllowedOptionsHook, useEvalDefaultValueHook, useEvalDisabledHook, useEvalDisplayHook, useEvalDynamicBoolHook, useEvalDynamicHook, useEvalLabelText, useEvalReadonlyHook, useEvalStyleHook, useEvalVisibilityHook, useJsonataExpression, useJsonataValidator, useLengthValidator, useMakeValidationHook, useUpdatedRef, useUuidExpression, validationVisitor, validatorOptions, visitControlData, visitControlDataArray, visitControlDefinition, visitFormData, visitFormDataInContext, withScalarOptions, wrapLayout, wrapMarkup, wrapMarkupAt };
+const _excluded = ["styleClass", "labelClass", "layoutClass", "labelTextClass", "textClass"],
+  _excluded2 = ["parentDataNode", "actionOnClick", "variables"];
+function RenderForm({
+  data,
+  form,
+  renderer,
+  options = {}
+}) {
+  var _effect = useComponentTracking();
+  try {
+    var _options$schemaInterf, _definition$adornment, _definition$adornment2, _dataContext$dataNode, _options$adjustLayout;
+    const schemaInterface = (_options$schemaInterf = options.schemaInterface) != null ? _options$schemaInterf : defaultSchemaInterface;
+    const [formState, setFormState] = useState(() => {
+      var _options$formState;
+      return (_options$formState = options == null ? void 0 : options.formState) != null ? _options$formState : createFormState(schemaInterface);
+    });
+    const state = formState.getControlState(data, form, options);
+    useEffect(() => {
+      if (!(options != null && options.formState)) {
+        return () => formState.cleanup();
+      }
+    }, [formState, options == null ? void 0 : options.formState]);
+    const definition = state.definition;
+    const visible = !state.hidden;
+    const visibility = useControl(() => visible != null ? {
+      visible,
+      showing: visible
+    } : undefined);
+    visibility.fields.visible.value = visible;
+    const dataContext = {
+      schemaInterface: state.schemaInterface,
+      dataNode: state.dataNode,
+      parentNode: data,
+      variables: state.variables
+    };
+    const adornments = (_definition$adornment = (_definition$adornment2 = definition.adornments) == null ? void 0 : _definition$adornment2.map(x => renderer.renderAdornment({
+      adornment: x,
+      dataContext,
+      formOptions: state
+    }))) != null ? _definition$adornment : [];
+    const {
+        styleClass,
+        labelClass,
+        labelTextClass,
+        textClass
+      } = options,
+      inheritableOptions = _objectWithoutPropertiesLoose(options, _excluded);
+    const {
+      readonly,
+      hidden,
+      disabled,
+      variables
+    } = state;
+    const childOptions = _extends({}, inheritableOptions, {
+      readonly,
+      disabled,
+      variables,
+      formState
+    });
+    const labelAndChildren = renderControlLayout({
+      formNode: form,
+      renderer,
+      state,
+      renderChild: (k, child, options) => {
+        var _ref2;
+        const overrideClasses = getGroupClassOverrides(definition);
+        const _ref = options != null ? options : {},
+          {
+            parentDataNode,
+            actionOnClick,
+            variables
+          } = _ref,
+          renderOptions = _objectWithoutPropertiesLoose(_ref, _excluded2);
+        const dContext = (_ref2 = parentDataNode != null ? parentDataNode : dataContext.dataNode) != null ? _ref2 : data;
+        const allChildOptions = _extends({}, childOptions, overrideClasses, renderOptions, {
+          variables: _extends({}, childOptions.variables, variables),
+          actionOnClick: actionHandlers(actionOnClick, childOptions.actionOnClick)
+        });
+        return /*#__PURE__*/jsx(RenderForm, {
+          form: child,
+          renderer: renderer,
+          data: dContext,
+          options: allChildOptions
+        }, k);
+      },
+      inline: options == null ? void 0 : options.inline,
+      displayOnly: options == null ? void 0 : options.displayOnly,
+      createDataProps: defaultDataProps,
+      formOptions: state,
+      dataContext,
+      control: (_dataContext$dataNode = dataContext.dataNode) == null ? void 0 : _dataContext$dataNode.control,
+      schemaInterface,
+      style: state.style,
+      allowedOptions: state.allowedOptions,
+      customDisplay: options.customDisplay,
+      actionOnClick: options.actionOnClick,
+      styleClass: styleClass,
+      labelClass: labelClass,
+      labelTextClass: labelTextClass,
+      textClass: textClass,
+      getChildState(child, parent) {
+        var _ref3;
+        return formState.getControlState((_ref3 = parent != null ? parent : state.dataNode) != null ? _ref3 : data, child, childOptions);
+      },
+      runExpression: (scope, expr, returnResult) => {
+        if (expr != null && expr.type) {
+          formState.evalExpression(expr, {
+            scope,
+            dataNode: data,
+            schemaInterface,
+            returnResult
+          });
+        }
+      }
+    });
+    const layoutProps = _extends({}, labelAndChildren, {
+      adornments,
+      className: rendererClass(options.layoutClass, definition.layoutClass),
+      style: state.layoutStyle
+    });
+    const renderedControl = renderer.renderLayout((_options$adjustLayout = options.adjustLayout == null ? void 0 : options.adjustLayout(dataContext, layoutProps)) != null ? _options$adjustLayout : layoutProps);
+    return renderer.renderVisibility(_extends({
+      visibility
+    }, renderedControl));
+  } finally {
+    _effect();
+  }
+}
+/**
+ * @deprecated Use RenderForm instead.
+ */
+function useControlRendererComponent(controlOrFormNode, renderer, options = {}, parentDataNode) {
+  const [definition, formNode] = "definition" in controlOrFormNode ? [controlOrFormNode.definition, controlOrFormNode] : [controlOrFormNode, legacyFormNode(controlOrFormNode)];
+  const r = useUpdatedRef({
+    options,
+    renderer,
+    parentDataNode,
+    formNode
+  });
+  return useMemo(() => () => {
+    const {
+      options,
+      parentDataNode,
+      formNode,
+      renderer
+    } = r.current;
+    return /*#__PURE__*/jsx(RenderForm, {
+      data: parentDataNode,
+      form: formNode,
+      renderer: renderer,
+      options: options
+    });
+  }, [r]);
+}
+/**
+ * @deprecated Use RenderForm instead.
+ */
+function ControlRenderer({
+  definition,
+  fields,
+  renderer,
+  options,
+  control,
+  parentPath
+}) {
+  var _effect2 = useComponentTracking();
+  try {
+    const schemaDataNode = createSchemaDataNode(createSchemaTree(fields).rootNode, control);
+    const Render = useControlRendererComponent(definition, renderer, options, schemaDataNode);
+    return /*#__PURE__*/jsx(Render, {});
+  } finally {
+    _effect2();
+  }
+}
+/**
+ * @deprecated Use RenderForm instead.
+ */
+function NewControlRenderer({
+  definition,
+  renderer,
+  options,
+  parentDataNode
+}) {
+  var _effect3 = useComponentTracking();
+  try {
+    const Render = useControlRendererComponent(definition, renderer, options, parentDataNode);
+    return /*#__PURE__*/jsx(Render, {});
+  } finally {
+    _effect3();
+  }
+}
+/**
+ * @deprecated Use RenderForm instead.
+ */
+function useControlRenderer(definition, fields, renderer, options = {}) {
+  const r = useUpdatedRef({
+    definition,
+    fields,
+    renderer,
+    options
+  });
+  return useCallback(({
+    control,
+    parentPath
+  }) => {
+    return /*#__PURE__*/jsx(ControlRenderer, _extends({}, r.current, {
+      control: control,
+      parentPath: parentPath
+    }));
+  }, [r]);
+}
+
+export { AppendAdornmentPriority, ControlRenderer, LabelType, NewControlRenderer, RenderForm, WrapAdornmentPriority, accordionOptions, actionControl, actionHandlers, addMissingControls, addMissingControlsForSchema, adornmentOptions, appendMarkup, appendMarkupAt, applyArrayLengthRestrictions, applyDefaultForField, applyDefaultValues, applyExtensionToSchema, applyExtensionsToSchema, applyLengthRestrictions, applyValues, autocompleteOptions, checkListOptions, cleanDataForSchema, coerceToString, collectDifferences, compoundControl, controlTitle, createAction, createActionRenderer, createAdornmentRenderer, createArrayActions, createArrayRenderer, createDataRenderer, createDisplayRenderer, createFormRenderer, createGroupRenderer, createLabelRenderer, createLayoutRenderer, createVisibilityRenderer, dataControl, dateValidatorOptions, deepMerge, defaultControlForField, defaultDataProps, defaultValueForField, defaultValueForFields, displayOnlyOptions, dynamicDefaultValue, dynamicDisabled, dynamicReadonly, dynamicVisibility, elementValueForField, emptyGroupDefinition, fieldDisplayName, fieldEqExpr, fieldExpr, fieldHasTag, fieldOptionAdornment, findChildDefinition, findCompoundField, findControlsForCompound, findFieldPath, findNonDataGroups, findScalarField, getAllReferencedClasses, getAllValues, getDiffObject, getExternalEditData, getGroupClassOverrides, getIsEditing, getLastDefinedValue, getLengthRestrictions, getNullToggler, getOverrideClass, groupedControl, hasOptions, htmlDisplayControl, isAccordionAdornment, isIconAdornment, isOptionalAdornment, isSetFieldAdornment, jsonataExpr, jsonataOptions, jsonataValidatorOptions, layoutKeyForPlacement, lengthValidatorOptions, lookupChildDataContext, mergeObjects, radioButtonOptions, renderControlLayout, renderLayoutParts, renderOptionsFor, rendererClass, textDisplayControl, textfieldOptions, useControlDefinitionForSchema, useControlRenderer, useControlRendererComponent, useExpression, useUpdatedRef, validationVisitor, validatorOptions, wrapLayout, wrapMarkup, wrapMarkupAt };
 //# sourceMappingURL=index.js.map