@astroapps/forms-core 1.2.3 → 2.0.1

package/lib/index.js

@@ -1,4 +1,4 @@
-import { ensureMetaValue, newControl, updateComputedValue, addDependent, createSyncEffect, createAsyncEffect, collectChanges, trackedValue, createCleanupScope, createEffect, trackControlChange, ControlChange, getCurrentFields, getMetaValue, createScopedEffect, getControlPath, unsafeRestoreControl } from '@astroapps/controls';
+import { ensureMetaValue, newControl, updateComputedValue, addDependent, createAsyncEffect, createSyncEffect, trackedValue, collectChanges, getCurrentFields, createCleanupScope, createEffect, trackControlChange, ControlChange, createScopedEffect, updateElements } from '@astroapps/controls';
 import jsonata from 'jsonata';
 import { v4 } from 'uuid';
 
@@ -21,6 +21,7 @@ var DynamicPropertyType;
   DynamicPropertyType["AllowedOptions"] = "AllowedOptions";
   DynamicPropertyType["Label"] = "Label";
   DynamicPropertyType["ActionData"] = "ActionData";
+  DynamicPropertyType["GridColumns"] = "GridColumns";
 })(DynamicPropertyType || (DynamicPropertyType = {}));
 var AdornmentPlacement;
 (function (AdornmentPlacement) {
@@ -66,6 +67,7 @@ var DataRenderType;
   DataRenderType["Array"] = "Array";
   DataRenderType["ArrayElement"] = "ArrayElement";
   DataRenderType["ElementSelected"] = "ElementSelected";
+  DataRenderType["ScrollList"] = "ScrollList";
 })(DataRenderType || (DataRenderType = {}));
 var SyncTextType;
 (function (SyncTextType) {
@@ -85,6 +87,7 @@ var GroupRenderType;
   GroupRenderType["Wizard"] = "Wizard";
   GroupRenderType["Dialog"] = "Dialog";
   GroupRenderType["Contents"] = "Contents";
+  GroupRenderType["Accordion"] = "Accordion";
 })(GroupRenderType || (GroupRenderType = {}));
 var DisplayDataType;
 (function (DisplayDataType) {
@@ -93,6 +96,12 @@ var DisplayDataType;
   DisplayDataType["Icon"] = "Icon";
   DisplayDataType["Custom"] = "Custom";
 })(DisplayDataType || (DisplayDataType = {}));
+var ControlDisableType;
+(function (ControlDisableType) {
+  ControlDisableType["None"] = "None";
+  ControlDisableType["Self"] = "Self";
+  ControlDisableType["Global"] = "Global";
+})(ControlDisableType || (ControlDisableType = {}));
 var ActionStyle;
 (function (ActionStyle) {
   ActionStyle["Button"] = "Button";
@@ -129,6 +138,9 @@ function isWizardRenderer(options) {
 function isDialogRenderer(options) {
   return options.type === GroupRenderType.Dialog;
 }
+function isAccordionRenderer(options) {
+  return options.type === GroupRenderType.Accordion;
+}
 function isInlineRenderer(options) {
   return options.type === GroupRenderType.Inline;
 }
@@ -229,7 +241,7 @@ function fontAwesomeIcon(icon) {
  * @returns True if the control definition is readonly, false otherwise.
  */
 function isControlReadonly(c) {
-  return isDataControl(c) && !!c.readonly;
+  return !!c.readonly;
 }
 /**
  * Checks if a control definition is disabled.
@@ -237,7 +249,7 @@ function isControlReadonly(c) {
  * @returns True if the control definition is disabled, false otherwise.
  */
 function isControlDisabled(c) {
-  return isDataControl(c) && !!c.disabled;
+  return !!c.disabled;
 }
 /**
  * Returns the group renderer options for a control definition.
@@ -265,6 +277,49 @@ function getDisplayOnlyOptions(d) {
   return isDataControl(d) && d.renderOptions && isDisplayOnlyRenderer(d.renderOptions) ? d.renderOptions : undefined;
 }
 
+function _extends() {
+  return _extends = Object.assign ? Object.assign.bind() : function (n) {
+    for (var e = 1; e < arguments.length; e++) {
+      var t = arguments[e];
+      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
+    }
+    return n;
+  }, _extends.apply(null, arguments);
+}
+
+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 = {}));
+function jsonataValidator$1(expr) {
+  return {
+    type: ValidatorType.Jsonata,
+    expression: expr
+  };
+}
+function dateValidator$1(comparison, fixedDate, daysFromCurrent) {
+  return {
+    type: ValidatorType.Date,
+    comparison,
+    fixedDate,
+    daysFromCurrent
+  };
+}
+function lengthValidator$1(min, max) {
+  return {
+    type: ValidatorType.Length,
+    min,
+    max
+  };
+}
+
 var ExpressionType;
 (function (ExpressionType) {
   ExpressionType["Jsonata"] = "Jsonata";
@@ -275,6 +330,157 @@ var ExpressionType;
   ExpressionType["UUID"] = "UUID";
 })(ExpressionType || (ExpressionType = {}));
 
+function dataControl(field, title, options) {
+  return _extends({
+    type: ControlDefinitionType.Data,
+    field,
+    title
+  }, options);
+}
+function validatorOptions(type) {
+  return o => _extends({
+    type
+  }, o);
+}
+function adornmentOptions(type) {
+  return o => _extends({
+    type
+  }, o);
+}
+function renderOptionsFor(type) {
+  return o => ({
+    renderOptions: _extends({
+      type
+    }, o)
+  });
+}
+const autocompleteOptions = renderOptionsFor(DataRenderType.Autocomplete);
+const checkListOptions = renderOptionsFor(DataRenderType.CheckList);
+const radioButtonOptions = renderOptionsFor(DataRenderType.Radio);
+const lengthValidatorOptions = validatorOptions(ValidatorType.Length);
+const jsonataValidatorOptions = validatorOptions(ValidatorType.Jsonata);
+const dateValidatorOptions = validatorOptions(ValidatorType.Date);
+const accordionOptions = adornmentOptions(ControlAdornmentType.Accordion);
+const textfieldOptions = renderOptionsFor(DataRenderType.Textfield);
+const displayOnlyOptions = renderOptionsFor(DataRenderType.DisplayOnly);
+const jsonataOptions = renderOptionsFor(DataRenderType.Jsonata);
+function textDisplayControl(text, options) {
+  return _extends({
+    type: ControlDefinitionType.Display,
+    displayData: {
+      type: DisplayDataType.Text,
+      text
+    }
+  }, options);
+}
+function htmlDisplayControl(html, options) {
+  return _extends({
+    type: ControlDefinitionType.Display,
+    displayData: {
+      type: DisplayDataType.Html,
+      html
+    }
+  }, options);
+}
+function dynamicDefaultValue(expr) {
+  return {
+    type: DynamicPropertyType.DefaultValue,
+    expr
+  };
+}
+function dynamicReadonly(expr) {
+  return {
+    type: DynamicPropertyType.Readonly,
+    expr
+  };
+}
+function dynamicVisibility(expr) {
+  return {
+    type: DynamicPropertyType.Visible,
+    expr
+  };
+}
+function dynamicDisabled(expr) {
+  return {
+    type: DynamicPropertyType.Disabled,
+    expr
+  };
+}
+function dataExpr(field) {
+  return {
+    type: ExpressionType.Data,
+    field
+  };
+}
+/**
+ * @deprecated Use dataExpr
+ */
+const fieldExpr = dataExpr;
+/**
+ * @deprecated Use dataMatchExpr
+ */
+const fieldEqExpr = dataMatchExpr;
+const uuidExpr = {
+  type: ExpressionType.UUID
+};
+function dataMatchExpr(field, value) {
+  return {
+    type: ExpressionType.DataMatch,
+    field,
+    value
+  };
+}
+function notEmptyExpr(field, empty) {
+  return {
+    type: ExpressionType.NotEmpty,
+    field,
+    empty
+  };
+}
+function jsonataExpr(expression) {
+  return {
+    type: ExpressionType.Jsonata,
+    expression
+  };
+}
+function groupedControl(children, title, options) {
+  return _extends({
+    type: ControlDefinitionType.Group,
+    children,
+    title,
+    groupOptions: {
+      type: "Standard",
+      hideTitle: !title
+    }
+  }, options);
+}
+function compoundControl(field, title, children, options) {
+  return _extends({
+    type: ControlDefinitionType.Data,
+    field,
+    children,
+    title,
+    renderOptions: {
+      type: "Standard"
+    }
+  }, options);
+}
+function actionControl(actionText, actionId, options) {
+  return _extends({
+    type: ControlDefinitionType.Action,
+    title: actionText,
+    actionId
+  }, options);
+}
+const emptyGroupDefinition = {
+  type: ControlDefinitionType.Group,
+  children: [],
+  groupOptions: {
+    type: GroupRenderType.Standard,
+    hideTitle: true
+  }
+};
+
 /**
  * Enum representing the various field types.
  */
@@ -366,20 +572,23 @@ function createSchemaTree(rootFields, lookup) {
   return new SchemaTreeImpl(rootFields, lookup);
 }
 class SchemaNode {
-  constructor(id, field, tree, parent) {
+  constructor(id, field, tree, parent, getChildFields) {
     this.id = void 0;
     this.field = void 0;
     this.tree = void 0;
     this.parent = void 0;
+    this.getChildFields = void 0;
     this.id = id;
     this.field = field;
     this.tree = tree;
     this.parent = parent;
+    this.getChildFields = getChildFields;
   }
   getSchema(schemaId) {
     return this.tree.getSchema(schemaId);
   }
   getUnresolvedFields() {
+    if (this.getChildFields) return this.getChildFields();
     return isCompoundField(this.field) ? this.field.children : [];
   }
   getResolvedParent(noRecurse) {
@@ -468,6 +677,52 @@ function schemaForFieldPath(fieldPath, schema) {
   }
   return schema;
 }
+function schemaForDataPath(fieldPath, schema) {
+  let i = 0;
+  let element = schema.field.collection;
+  while (i < fieldPath.length) {
+    const nextField = fieldPath[i];
+    let childNode;
+    if (nextField == ".") {
+      i++;
+      continue;
+    } else if (nextField == "..") {
+      if (element) {
+        element = false;
+        i++;
+        continue;
+      }
+      childNode = schema.parent;
+    } else {
+      childNode = schema.getChildNode(nextField);
+    }
+    if (!childNode) {
+      childNode = createSchemaNode(missingField(nextField), schema.tree, schema);
+    } else {
+      element = childNode.field.collection;
+    }
+    schema = childNode;
+    i++;
+  }
+  return {
+    node: schema,
+    element: !!element
+  };
+}
+function getParentDataPath({
+  node,
+  element
+}) {
+  if (element) return {
+    node,
+    element: false
+  };
+  const parent = node.parent;
+  return parent ? {
+    node: parent,
+    element: !!parent.field.collection
+  } : undefined;
+}
 function getSchemaNodePath(node) {
   const paths = [];
   let curNode = node;
@@ -510,16 +765,6 @@ function relativeSegmentPath(parentPath, childPath) {
   return "../".repeat(upLevels) + downPath;
 }
 
-function _extends() {
-  return _extends = Object.assign ? Object.assign.bind() : function (n) {
-    for (var e = 1; e < arguments.length; e++) {
-      var t = arguments[e];
-      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
-    }
-    return n;
-  }, _extends.apply(null, arguments);
-}
-
 function buildSchema(def) {
   return Object.entries(def).map(x => x[1](x[0]));
 }
@@ -621,6 +866,9 @@ function mergeOption(fields, name, value, fieldName) {
   return fields.map(x => x.field === fieldName ? addFieldOption(x, name, value) : x);
 }
 function mergeFields(fields, name, value, newFields) {
+  if (name === "*") {
+    return newFields.reduce((af, x) => mergeField(x, af), fields);
+  }
   const withType = fields.map(x => x.isTypeField ? addFieldOption(x, name, value) : x);
   return newFields.map(x => _extends({}, x, {
     onlyForTypes: [value]
@@ -660,18 +908,6 @@ function resolveSchemas(schemaMap) {
   return out;
 }
 
-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 = {}));
-
 class SchemaDataTree {}
 class SchemaDataNode {
   constructor(id, schema, elementIndex, control, tree, parent) {
@@ -774,6 +1010,15 @@ function hideDisplayOnly(context, schemaInterface, definition) {
   const displayOptions = getDisplayOnlyOptions(definition);
   return displayOptions && !displayOptions.emptyText && schemaInterface.isEmptyValue(context.schema.field, (_context$control = context.control) == null ? void 0 : _context$control.value);
 }
+function getLoadingControl(data) {
+  return ensureMetaValue(data, "loading", () => newControl(false));
+}
+function getRefreshingControl(data) {
+  return ensureMetaValue(data, "refreshing", () => newControl(false));
+}
+function getHasMoreControl(data) {
+  return ensureMetaValue(data, "hasMore", () => newControl(false));
+}
 
 class DefaultSchemaInterface {
   constructor(boolStrings = ["No", "Yes"], parseDateTime = s => Date.parse(s)) {
@@ -847,7 +1092,7 @@ class DefaultSchemaInterface {
       case FieldType.Time:
         return value ? new Date("1970-01-01T" + value).toLocaleTimeString() : undefined;
       case FieldType.Bool:
-        return this.boolStrings[value ? 1 : 0];
+        return value != null ? this.boolStrings[value ? 1 : 0] : undefined;
       default:
         return value != null ? value.toString() : undefined;
     }
@@ -857,8 +1102,8 @@ class DefaultSchemaInterface {
     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;
+    const len = value == null ? void 0 : value.length;
+    return typeof len === "number" ? len : 0;
   }
   compareValue(field, v1, v2) {
     if (v1 == null) return v2 == null ? 0 : 1;
@@ -870,7 +1115,7 @@ class DefaultSchemaInterface {
       case FieldType.String:
         return v1.localeCompare(v2);
       case FieldType.Bool:
-        return v1 ? v2 ? 0 : 1 : -1;
+        return v1 === v2 ? 0 : !v1 ? -1 : 1;
       case FieldType.Int:
       case FieldType.Double:
         return v1 - v2;
@@ -1002,12 +1247,12 @@ class FormTreeImpl extends FormTree {
   }
 }
 function legacyFormNode(definition) {
-  return createFormTree([definition]).rootNode.getChildNodes()[0];
+  return createFormTree([definition]).rootNode;
 }
 function createFormTree(controls, getForm = {
   getForm: () => undefined
 }) {
-  return new FormTreeImpl(getForm, {
+  return new FormTreeImpl(getForm, controls.length === 1 ? controls[0] : {
     type: ControlDefinitionType.Group,
     children: controls,
     groupOptions: {
@@ -1077,35 +1322,6 @@ function visitFormDataInContext(parentContext, node, cb) {
   const dataNode = lookupDataNode(node.definition, parentContext);
   return visitFormData(node, dataNode != null ? dataNode : parentContext, cb, !dataNode);
 }
-function visitFormDataNode(node, visitFn) {
-  const dataNode = lookupDataNode(node.formNode.definition, node.parentData);
-  const v = visitFn(node, dataNode);
-  if (v !== undefined) return v;
-  const parentData = dataNode != null ? dataNode : node.parentData;
-  if (parentData.schema.field.collection && parentData.elementIndex == null) {
-    const elemCount = parentData.control.elements.length;
-    for (let i = 0; i < elemCount; i++) {
-      const _v = visitChildren(parentData.getChildElement(i));
-      if (_v !== undefined) return _v;
-    }
-    return undefined;
-  } else {
-    return visitChildren(parentData);
-  }
-  function visitChildren(parentData) {
-    const children = node.formNode.getChildNodes();
-    for (let i = 0; i < children.length; i++) {
-      const child = children[i];
-      const res = visitFormDataNode({
-        formNode: child,
-        parent: node,
-        parentData,
-        childIndex: i
-      }, visitFn);
-      if (res !== undefined) return res;
-    }
-  }
-}
 
 /**
  * Converts a JSON path array to a string.
@@ -1202,9 +1418,14 @@ const jsonataEval = (expr, {
     }
   });
   async function runJsonata(effect, signal) {
-    const bindings = collectChanges(effect.collectUsage, () => variables == null ? void 0 : variables.value);
-    const evalResult = await parsedJsonata.fields.expr.value.evaluate(trackedValue(rootData, effect.collectUsage), bindings);
-    // console.log(parsedJsonata.fields.fullExpr.value, evalResult, bindings);
+    const trackedVars = variables == null ? void 0 : variables(effect.collectUsage);
+    const evalResult = await parsedJsonata.fields.expr.value.evaluate(trackedValue(rootData, effect.collectUsage), trackedVars);
+    // console.log(
+    //   rootData,
+    //   parsedJsonata.fields.fullExpr.current.value,
+    //   evalResult,
+    //   trackedVars,
+    // );
     collectChanges(effect.collectUsage, () => returnResult(evalResult));
   }
   const asyncEffect = createAsyncEffect(runJsonata, scope);
@@ -1220,6 +1441,54 @@ const defaultEvaluators = {
   [ExpressionType.Jsonata]: jsonataEval,
   [ExpressionType.UUID]: uuidEval
 };
+function createEvalExpr(evalExpression, context) {
+  function evalExpr(scope, init, nk, e, coerce) {
+    nk.value = init;
+    if (e != null && e.type) {
+      evalExpression(e, _extends({
+        returnResult: r => {
+          nk.value = coerce(r);
+        },
+        scope
+      }, context));
+      return true;
+    }
+    return false;
+  }
+  return evalExpr;
+}
+
+function createOverrideProxy(proxyFor, handlers) {
+  const overrides = getCurrentFields(handlers);
+  const allOwn = Reflect.ownKeys(proxyFor);
+  Reflect.ownKeys(overrides).forEach(k => {
+    if (!allOwn.includes(k)) allOwn.push(k);
+  });
+  return new Proxy(proxyFor, {
+    get(target, p, receiver) {
+      if (Object.hasOwn(overrides, p)) {
+        const nv = overrides[p].value;
+        if (nv !== NoOverride) return nv;
+      }
+      return Reflect.get(target, p, receiver);
+    },
+    ownKeys(target) {
+      return allOwn;
+    },
+    has(target, p) {
+      return Reflect.has(proxyFor, p) || Reflect.has(overrides, p);
+    },
+    getOwnPropertyDescriptor(target, k) {
+      if (Object.hasOwn(overrides, k)) return {
+        enumerable: true,
+        configurable: true
+      };
+      return Reflect.getOwnPropertyDescriptor(target, k);
+    }
+  });
+}
+class NoValue {}
+const NoOverride = new NoValue();
 
 const jsonataValidator = (validation, context) => {
   const error = createScopedComputed(context, () => undefined);
@@ -1235,7 +1504,7 @@ const jsonataValidator = (validation, context) => {
       context.data.control.setError("jsonata", v == null ? void 0 : v.toString());
     },
     schemaInterface: context.schemaInterface,
-    variables: context.formContext.fields.variables,
+    variables: context.variables,
     runAsync: context.runAsync
   });
 };
@@ -1303,7 +1572,7 @@ function createValidators(def, context) {
     if (def.required) {
       context.addSync(v => {
         const field = context.data.schema.field;
-        return schemaInterface.isEmptyValue(field, v) ? schemaInterface.validationMessageText(field, ValidationMessageType.NotEmpty, false, true) : null;
+        return schemaInterface.isEmptyValue(field, v) ? def.requiredErrorText ? def.requiredErrorText : schemaInterface.validationMessageText(field, ValidationMessageType.NotEmpty, false, true) : null;
       });
     }
     (_def$validators = def.validators) == null || _def$validators.forEach(x => {
@@ -1312,15 +1581,15 @@ function createValidators(def, context) {
     });
   }
 }
-function setupValidation(controlImpl, definition, dataNode, schemaInterface, parent, formNode, hidden, runAsync) {
-  const validationEnabled = createScopedComputed(controlImpl, () => !hidden.value);
+function setupValidation(scope, variables, definition, dataNode, schemaInterface, parent, visible, runAsync) {
+  const validationEnabled = createScopedComputed(scope, () => !!visible.value);
   const validatorsScope = createCleanupScope();
   createEffect(() => {
     validatorsScope.cleanup();
     const dn = dataNode.value;
     if (dn) {
       let syncValidations = [];
-      createValidators(formNode.definition, {
+      createValidators(definition, {
         data: dn,
         parentData: parent,
         validationEnabled,
@@ -1331,7 +1600,7 @@ function setupValidation(controlImpl, definition, dataNode, schemaInterface, par
         addCleanup(cleanup) {
           validatorsScope.addCleanup(cleanup);
         },
-        formContext: controlImpl,
+        variables,
         runAsync
       });
       createEffect(() => {
@@ -1348,234 +1617,534 @@ function setupValidation(controlImpl, definition, dataNode, schemaInterface, par
         dn.control.setError("default", e);
       }, validatorsScope);
     }
-  }, c => {}, controlImpl);
+  }, c => {}, scope);
 }
 
-function getControlStateId(parent, formNode, stateKey) {
-  return parent.id + "$" + formNode.id + (stateKey != null ? stateKey : "");
-}
-function createFormState(schemaInterface, evaluators = defaultEvaluators) {
-  // console.log("createFormState");
-  const controlStates = newControl({});
-  function evalExpression(e, context) {
-    const x = evaluators[e.type];
-    x == null || x(e, context);
-  }
-  return {
-    evalExpression,
-    cleanup: () => {
-      // console.log("Cleanup form state");
-      controlStates.cleanup();
-    },
-    getExistingControlState(parent, formNode, stateKey) {
-      const stateId = getControlStateId(parent, formNode, stateKey);
-      const control = getCurrentFields(controlStates)[stateId];
-      if (control) {
-        var _getMetaValue;
-        return (_getMetaValue = getMetaValue(control, "impl")) == null ? void 0 : _getMetaValue.value;
-      }
-      return undefined;
-    },
-    getControlState(parent, formNode, context, runAsync) {
-      const stateId = getControlStateId(parent, formNode, context.stateKey);
-      const controlImpl = controlStates.fields[stateId];
-      controlImpl.value = context;
-      function evalExpr(scope, init, nk, e, coerce) {
-        nk.value = init;
-        if (e != null && e.type) {
-          evalExpression(e, {
-            returnResult: r => {
-              nk.value = coerce(r);
-            },
-            scope,
-            dataNode: parent,
-            variables: controlImpl.fields.variables,
-            schemaInterface,
-            runAsync
-          });
-          return true;
-        }
-        return false;
+function createEvaluatedDefinition(def, evalExpr, scope, display) {
+  const definitionOverrides = createScoped(scope, {});
+  const displayOverrides = createScoped(scope, {});
+  const groupOptionsOverrides = createScoped(scope, {});
+  const renderOptionsOverrides = createScoped(scope, {});
+  const {
+    hidden,
+    displayData,
+    readonly,
+    disabled,
+    defaultValue,
+    actionData,
+    title,
+    groupOptions,
+    renderOptions
+  } = definitionOverrides.fields;
+  const {
+    columns
+  } = groupOptionsOverrides.fields;
+  const {
+    groupOptions: dataGroupRenderOptions
+  } = renderOptionsOverrides.fields;
+  const {
+    html,
+    text
+  } = displayOverrides.fields;
+  updateComputedValue(dataGroupRenderOptions, () => {
+    var _def$renderOptions$gr;
+    return isDataControl(def) && isDataGroupRenderer(def.renderOptions) ? createOverrideProxy((_def$renderOptions$gr = def.renderOptions.groupOptions) != null ? _def$renderOptions$gr : {}, groupOptionsOverrides) : undefined;
+  });
+  updateComputedValue(displayData, () => isDisplayControl(def) ? createOverrideProxy(def.displayData, displayOverrides) : undefined);
+  updateComputedValue(groupOptions, () => {
+    const groupOptions = getGroupRendererOptions(def);
+    return groupOptions ? createOverrideProxy(groupOptions, groupOptionsOverrides) : undefined;
+  });
+  updateComputedValue(renderOptions, () => {
+    var _def$renderOptions;
+    return isDataControl(def) ? createOverrideProxy((_def$renderOptions = def.renderOptions) != null ? _def$renderOptions : {}, renderOptionsOverrides) : undefined;
+  });
+  evalDynamic(hidden, DynamicPropertyType.Visible,
+  // Make sure it's not null if no scripting
+  x => x ? def.hidden : !!def.hidden, r => !r);
+  evalDynamic(readonly, DynamicPropertyType.Readonly, () => isControlReadonly(def), r => !!r);
+  createScopedEffect(c => {
+    evalExpr(c, isControlDisabled(def), disabled, firstExpr(DynamicPropertyType.Disabled), r => !!r);
+  }, definitionOverrides);
+  createScopedEffect(c => {
+    const groupOptions = getGroupRendererOptions(def);
+    evalExpr(c, groupOptions == null ? void 0 : groupOptions.columns, columns, groupOptions ? firstExpr(DynamicPropertyType.GridColumns) : undefined, r => typeof r === "number" ? r : undefined);
+  }, groupOptionsOverrides);
+  createScopedEffect(c => {
+    evalExpr(c, isDataControl(def) ? def.defaultValue : undefined, defaultValue, isDataControl(def) ? firstExpr(DynamicPropertyType.DefaultValue) : undefined, r => r);
+  }, definitionOverrides);
+  createScopedEffect(c => {
+    evalExpr(c, isActionControl(def) ? def.actionData : undefined, actionData, isActionControl(def) ? firstExpr(DynamicPropertyType.ActionData) : undefined, r => r);
+  }, definitionOverrides);
+  createScopedEffect(c => {
+    evalExpr(c, def.title, title, firstExpr(DynamicPropertyType.Label), coerceString);
+  }, definitionOverrides);
+  createSyncEffect(() => {
+    if (isDisplayControl(def)) {
+      if (display.value !== undefined) {
+        text.value = isTextDisplay(def.displayData) ? display.value : NoOverride;
+        html.value = isHtmlDisplay(def.displayData) ? display.value : NoOverride;
+      } else {
+        text.value = NoOverride;
+        html.value = NoOverride;
       }
-      return createScopedMetaValue(formNode, controlImpl, "impl", scope => {
-        var _controlImpl$fields$v;
-        const cf = controlImpl.fields;
-        const definitionOverrides = createScoped(controlImpl, {});
-        createScoped(controlImpl, undefined);
-        const displayOverrides = createScoped(controlImpl, {});
-        const def = formNode.definition;
-        const definition = createOverrideProxy(def, definitionOverrides);
-        const of = definitionOverrides.fields;
-        const {
-          text,
-          html
-        } = displayOverrides.fields;
-        updateComputedValue(of.displayData, () => isDisplayControl(def) ? createOverrideProxy(def.displayData, displayOverrides) : undefined);
-        createScopedEffect(c => {
-          evalExpr(c, def.hidden, of.hidden, firstExpr(formNode, DynamicPropertyType.Visible), r => !r);
-        }, definitionOverrides);
-        createScopedEffect(c => {
-          evalExpr(c, isControlReadonly(def), of.readonly, firstExpr(formNode, DynamicPropertyType.Readonly), r => !!r);
-        }, definitionOverrides);
-        createScopedEffect(c => {
-          evalExpr(c, isControlDisabled(def), of.disabled, firstExpr(formNode, DynamicPropertyType.Disabled), r => !!r);
-        }, definitionOverrides);
-        createScopedEffect(c => {
-          evalExpr(c, isDataControl(def) ? def.defaultValue : undefined, of.defaultValue, isDataControl(def) ? firstExpr(formNode, DynamicPropertyType.DefaultValue) : undefined, r => r);
-        }, definitionOverrides);
-        createScopedEffect(c => {
-          evalExpr(c, isActionControl(def) ? def.actionData : undefined, of.actionData, isActionControl(def) ? firstExpr(formNode, DynamicPropertyType.ActionData) : undefined, r => r);
-        }, definitionOverrides);
-        createScopedEffect(c => {
-          evalExpr(c, def.title, of.title, firstExpr(formNode, DynamicPropertyType.Label), coerceString);
-        }, definitionOverrides);
-        const control = createScoped(controlImpl, {
-          definition,
-          dataNode: undefined,
-          schemaInterface,
-          disabled: false,
-          readonly: false,
-          clearHidden: false,
-          hidden: false,
-          variables: (_controlImpl$fields$v = controlImpl.fields.variables.current.value) != null ? _controlImpl$fields$v : {},
-          stateId,
-          meta: newControl({})
-        });
-        const {
-          dataNode,
-          hidden,
-          readonly,
-          style,
-          layoutStyle,
-          allowedOptions,
-          disabled,
-          variables,
-          display
-        } = control.fields;
-        createScopedEffect(c => evalExpr(c, undefined, style, firstExpr(formNode, DynamicPropertyType.Style), coerceStyle), scope);
-        createScopedEffect(c => evalExpr(c, undefined, layoutStyle, firstExpr(formNode, DynamicPropertyType.LayoutStyle), coerceStyle), scope);
-        createScopedEffect(c => evalExpr(c, undefined, allowedOptions, firstExpr(formNode, DynamicPropertyType.AllowedOptions), x => x), scope);
-        createScopedEffect(c => evalExpr(c, undefined, display, firstExpr(formNode, DynamicPropertyType.Display), coerceString), scope);
-        updateComputedValue(dataNode, () => lookupDataNode(definition, parent));
-        updateComputedValue(hidden, () => !!cf.hidden.value || definition.hidden || dataNode.value && (!validDataNode(dataNode.value) || hideDisplayOnly(dataNode.value, schemaInterface, definition)));
-        updateComputedValue(readonly, () => !!cf.readonly.value || isControlReadonly(definition));
-        updateComputedValue(disabled, () => !!cf.disabled.value || of.disabled.value);
-        updateComputedValue(variables, () => {
-          var _controlImpl$fields$v2;
-          return (_controlImpl$fields$v2 = controlImpl.fields.variables.value) != null ? _controlImpl$fields$v2 : {};
-        });
-        createSyncEffect(() => {
-          const dn = dataNode.value;
-          if (dn) {
-            dn.control.disabled = disabled.value;
-          }
-        }, scope);
-        createSyncEffect(() => {
-          if (isDisplayControl(def)) {
-            if (display.value !== undefined) {
-              text.value = isTextDisplay(def.displayData) ? display.value : NoOverride;
-              html.value = isHtmlDisplay(def.displayData) ? display.value : NoOverride;
-            } else {
-              text.value = NoOverride;
-              html.value = NoOverride;
-            }
-          }
-        }, displayOverrides);
-        setupValidation(controlImpl, definition, dataNode, schemaInterface, parent, formNode, hidden, runAsync);
-        createSyncEffect(() => {
-          var _dataNode$value;
-          const dn = (_dataNode$value = dataNode.value) == null ? void 0 : _dataNode$value.control;
-          if (dn && isDataControl(definition)) {
-            var _definition$adornment, _definition$renderOpt;
-            if (definition.hidden) {
-              if (controlImpl.fields.clearHidden.value && !definition.dontClearHidden) {
-                // console.log("Clearing hidden");
-                dn.value = undefined;
-              }
-            } else if (dn.value === undefined && definition.defaultValue != null && !((_definition$adornment = definition.adornments) != null && _definition$adornment.some(x => x.type === ControlAdornmentType.Optional)) && ((_definition$renderOpt = definition.renderOptions) == null ? void 0 : _definition$renderOpt.type) != DataRenderType.NullToggle) {
-              // console.log(
-              //   "Setting to default",
-              //   definition.defaultValue,
-              //   definition.field,
-              // );
-              // const [required, dcv] = isDataControl(definition)
-              //   ? [definition.required, definition.defaultValue]
-              //   : [false, undefined];
-              // const field = ctx.dataNode?.schema.field;
-              // return (
-              //   dcv ??
-              //   (field
-              //     ? ctx.dataNode!.elementIndex != null
-              //       ? elementValueForField(field)
-              //       : defaultValueForField(field, required)
-              //     : undefined)
-              // );
-              dn.value = definition.defaultValue;
-            }
-          }
-        }, scope);
-        return createOverrideProxy(control.current.value, control);
-      });
     }
-  };
-}
-function firstExpr(formNode, property) {
-  var _formNode$definition$;
-  return (_formNode$definition$ = formNode.definition.dynamic) == null || (_formNode$definition$ = _formNode$definition$.find(x => x.type === property && x.expr.type)) == null ? void 0 : _formNode$definition$.expr;
+  }, displayOverrides);
+  return createOverrideProxy(def, definitionOverrides);
+  function firstExpr(property) {
+    var _def$dynamic;
+    return (_def$dynamic = def.dynamic) == null || (_def$dynamic = _def$dynamic.find(x => x.type === property && x.expr.type)) == null ? void 0 : _def$dynamic.expr;
+  }
+  function evalDynamic(control, property, init, coerce) {
+    createScopedEffect(c => {
+      const x = firstExpr(property);
+      evalExpr(c, init(x), control, x, coerce);
+    }, scope);
+  }
 }
 function coerceStyle(v) {
   return typeof v === "object" ? v : undefined;
 }
 function coerceString(v) {
-  var _v$toString;
-  return typeof v === "string" ? v : (_v$toString = v == null ? void 0 : v.toString()) != null ? _v$toString : "";
+  if (typeof v === "string") return v;
+  if (v == null) return "";
+  switch (typeof v) {
+    case "number":
+    case "boolean":
+      return v.toString();
+    default:
+      return JSON.stringify(v);
+  }
 }
-function createScopedMetaValue(formNode, c, key, init) {
-  return ensureMetaValue(c, key, () => {
-    const holder = createScoped(c, undefined, {
-      equals: (a, b) => a === b
+function createFormStateNode(formNode, parent, options, nodeOptions) {
+  const globals = newControl({
+    schemaInterface: options.schemaInterface,
+    evalExpression: options.evalExpression,
+    runAsync: options.runAsync,
+    resolveChildren: options.resolveChildren,
+    clearHidden: options.clearHidden
+  });
+  return new FormStateNodeImpl("ROOT", {}, formNode.definition, formNode, nodeOptions, globals, parent, undefined, 0, options.resolveChildren);
+}
+const noopUi = {
+  ensureChildVisible(childIndex) {},
+  ensureVisible() {},
+  getDisabler(type) {
+    return () => () => {};
+  }
+};
+class FormStateNodeImpl {
+  constructor(childKey, meta, definition, form, nodeOptions, globals, parent, parentNode, childIndex, resolveChildren) {
+    this.childKey = void 0;
+    this.meta = void 0;
+    this.form = void 0;
+    this.globals = void 0;
+    this.parent = void 0;
+    this.parentNode = void 0;
+    this.base = void 0;
+    this.options = void 0;
+    this.resolveChildren = void 0;
+    this.ui = noopUi;
+    this.childKey = childKey;
+    this.meta = meta;
+    this.form = form;
+    this.globals = globals;
+    this.parent = parent;
+    this.parentNode = parentNode;
+    const base = newControl({
+      readonly: false,
+      visible: null,
+      disabled: false,
+      children: [],
+      resolved: {
+        definition
+      },
+      parent,
+      allowedOptions: undefined,
+      childIndex,
+      nodeOptions,
+      busy: false
+    }, {
+      dontClearError: true
     });
-    const effect = createScopedEffect(c => holder.value = init(c), holder);
-    effect.run = () => {
-      console.log("ControlState being recreated:", effect.subscriptions.map(x => {
-        var _x$;
-        return `${(_x$ = x[1]) == null ? void 0 : _x$.mask} ${jsonPathString(getControlPath(x[0], unsafeRestoreControl(formNode.definition)))}`;
-      }));
-    };
-    return holder;
-  }).value;
+    this.base = base;
+    this.options = base.fields.nodeOptions;
+    base.meta["$FormState"] = this;
+    this.resolveChildren = resolveChildren != null ? resolveChildren : globals.fields.resolveChildren.value;
+    initFormState(definition, this, parentNode);
+  }
+  get busy() {
+    return this.base.fields.busy.value;
+  }
+  setBusy(busy) {
+    this.base.fields.busy.value = busy;
+  }
+  get evalExpression() {
+    return this.globals.fields.evalExpression.value;
+  }
+  get runAsync() {
+    return this.globals.fields.runAsync.value;
+  }
+  get schemaInterface() {
+    return this.globals.fields.schemaInterface.value;
+  }
+  get forceDisabled() {
+    return this.options.fields.forceDisabled.value;
+  }
+  setForceDisabled(value) {
+    return this.options.fields.forceDisabled.value = value;
+  }
+  get forceReadonly() {
+    return this.options.fields.forceReadonly.value;
+  }
+  get forceHidden() {
+    return this.options.fields.forceHidden.value;
+  }
+  attachUi(f) {
+    this.ui = f;
+  }
+  get childIndex() {
+    return this.base.fields.childIndex.value;
+  }
+  get children() {
+    return this.base.fields.children.elements.map(x => x.meta["$FormState"]);
+  }
+  get uniqueId() {
+    return this.base.uniqueId.toString();
+  }
+  get valid() {
+    return this.base.valid;
+  }
+  get touched() {
+    return this.base.touched;
+  }
+  setTouched(touched, notChildren) {
+    this.base.setTouched(touched, notChildren);
+  }
+  validate() {
+    this.children.forEach(child => {
+      child.validate();
+    });
+    if (this.dataNode) {
+      this.dataNode.control.validate();
+    }
+    return this.valid;
+  }
+  get readonly() {
+    return this.base.fields.readonly.value;
+  }
+  get visible() {
+    return this.base.fields.visible.value;
+  }
+  get disabled() {
+    return this.base.fields.disabled.value;
+  }
+  get clearHidden() {
+    return this.globals.fields.clearHidden.value;
+  }
+  get variables() {
+    return this.options.fields.variables.value;
+  }
+  get definition() {
+    return this.resolved.definition;
+  }
+  getChild(index) {
+    var _this$base$fields$chi;
+    return (_this$base$fields$chi = this.base.fields.children.elements[index]) == null ? void 0 : _this$base$fields$chi.meta["$FormState"];
+  }
+  getChildCount() {
+    return this.base.fields.children.elements.length;
+  }
+  cleanup() {
+    this.base.cleanup();
+  }
+  get resolved() {
+    return this.base.fields.resolved.value;
+  }
+  get dataNode() {
+    return this.base.fields.dataNode.value;
+  }
+  ensureMeta(key, init) {
+    if (key in this.meta) return this.meta[key];
+    const res = init(this.base);
+    this.meta[key] = res;
+    return res;
+  }
 }
-function createOverrideProxy(proxyFor, handlers) {
-  const overrides = getCurrentFields(handlers);
-  const allOwn = Reflect.ownKeys(proxyFor);
-  Reflect.ownKeys(overrides).forEach(k => {
-    if (!allOwn.includes(k)) allOwn.push(k);
+function initFormState(def, impl, parentNode) {
+  const {
+    base,
+    options,
+    schemaInterface,
+    runAsync,
+    evalExpression,
+    parent,
+    variables
+  } = impl;
+  const evalExpr = createEvalExpr(evalExpression, {
+    schemaInterface,
+    variables,
+    dataNode: parent,
+    runAsync
   });
-  return new Proxy(proxyFor, {
-    get(target, p, receiver) {
-      if (Object.hasOwn(overrides, p)) {
-        const nv = overrides[p].value;
-        if (nv !== NoOverride) return nv;
-      }
-      return Reflect.get(target, p, receiver);
-    },
-    ownKeys(target) {
-      return allOwn;
-    },
-    has(target, p) {
-      return Reflect.has(proxyFor, p) || Reflect.has(overrides, p);
-    },
-    getOwnPropertyDescriptor(target, k) {
-      if (Object.hasOwn(overrides, k)) return {
-        enumerable: true,
-        configurable: true
+  const scope = base;
+  const {
+    forceReadonly,
+    forceDisabled,
+    forceHidden
+  } = options.fields;
+  const resolved = base.fields.resolved.as();
+  const {
+    style,
+    layoutStyle,
+    fieldOptions,
+    display,
+    definition: rd
+  } = resolved.fields;
+  evalDynamic(display, DynamicPropertyType.Display, undefined, coerceString);
+  const {
+    dataNode,
+    readonly,
+    disabled,
+    visible,
+    children,
+    allowedOptions
+  } = base.fields;
+  const definition = createEvaluatedDefinition(def, evalExpr, scope, display);
+  rd.value = definition;
+  evalDynamic(style, DynamicPropertyType.Style, undefined, coerceStyle);
+  evalDynamic(layoutStyle, DynamicPropertyType.LayoutStyle, undefined, coerceStyle);
+  evalDynamic(allowedOptions, DynamicPropertyType.AllowedOptions, undefined, x => x);
+  updateComputedValue(dataNode, () => lookupDataNode(definition, parent));
+  updateComputedValue(visible, () => {
+    if (forceHidden.value) return false;
+    if (parentNode && !parentNode.visible) return parentNode.visible;
+    const dn = dataNode.value;
+    if (dn && (!validDataNode(dn) || hideDisplayOnly(dn, schemaInterface, definition))) return false;
+    return definition.hidden == null ? null : !definition.hidden;
+  });
+  updateComputedValue(readonly, () => (parentNode == null ? void 0 : parentNode.readonly) || forceReadonly.value || isControlReadonly(definition));
+  updateComputedValue(disabled, () => (parentNode == null ? void 0 : parentNode.disabled) || forceDisabled.value || isControlDisabled(definition));
+  updateComputedValue(fieldOptions, () => {
+    var _allowedOptions$value;
+    const dn = dataNode.value;
+    if (!dn) return undefined;
+    const fieldOptions = schemaInterface.getDataOptions(dn);
+    const _allowed = (_allowedOptions$value = allowedOptions.value) != null ? _allowedOptions$value : [];
+    const allowed = Array.isArray(_allowed) ? _allowed : [_allowed];
+    return 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 : {
+        name: x.toString(),
+        value: x
       };
-      return Reflect.getOwnPropertyDescriptor(target, k);
-    }
+    }).filter(x => x != null) : fieldOptions;
   });
+  createSyncEffect(() => {
+    const dn = dataNode.value;
+    if (dn) {
+      dn.control.disabled = disabled.value;
+    }
+  }, scope);
+  createSyncEffect(() => {
+    const dn = dataNode.value;
+    if (dn) {
+      dn.control.touched = base.touched;
+    }
+  }, scope);
+  createSyncEffect(() => {
+    const dn = dataNode.value;
+    if (dn) {
+      base.touched = dn.control.touched;
+    }
+  }, scope);
+  createSyncEffect(() => {
+    const dn = dataNode.value;
+    base.setErrors(dn == null ? void 0 : dn.control.errors);
+  }, scope);
+  setupValidation(scope, impl.variables, definition, dataNode, schemaInterface, parent, visible, runAsync);
+  createSyncEffect(() => {
+    var _dataNode$value;
+    const dn = (_dataNode$value = dataNode.value) == null ? void 0 : _dataNode$value.control;
+    if (dn && isDataControl(definition)) {
+      var _definition$adornment, _definition$renderOpt;
+      if (impl.visible == false) {
+        if (impl.clearHidden && !definition.dontClearHidden) {
+          // console.log("Clearing hidden");
+          dn.value = undefined;
+        }
+      } else if (impl.visible && dn.value === undefined && definition.defaultValue != null && !((_definition$adornment = definition.adornments) != null && _definition$adornment.some(x => x.type === ControlAdornmentType.Optional)) && ((_definition$renderOpt = definition.renderOptions) == null ? void 0 : _definition$renderOpt.type) != DataRenderType.NullToggle) {
+        // console.log(
+        //   "Setting to default",
+        //   definition.defaultValue,
+        //   definition.field,
+        // );
+        // const [required, dcv] = isDataControl(definition)
+        //   ? [definition.required, definition.defaultValue]
+        //   : [false, undefined];
+        // const field = ctx.dataNode?.schema.field;
+        // return (
+        //   dcv ??
+        //   (field
+        //     ? ctx.dataNode!.elementIndex != null
+        //       ? elementValueForField(field)
+        //       : defaultValueForField(field, required)
+        //     : undefined)
+        // );
+        dn.value = definition.defaultValue;
+      }
+    }
+  }, scope);
+  initChildren(impl);
+  function firstExpr(property) {
+    var _def$dynamic2;
+    return (_def$dynamic2 = def.dynamic) == null || (_def$dynamic2 = _def$dynamic2.find(x => x.type === property && x.expr.type)) == null ? void 0 : _def$dynamic2.expr;
+  }
+  function evalDynamic(control, property, init, coerce) {
+    createScopedEffect(c => evalExpr(c, init, control, firstExpr(property), coerce), scope);
+  }
+}
+function combineVariables(v1, v2) {
+  if (!v1) return v2;
+  if (!v2) return v1;
+  return c => _extends({}, v1(c), v2(c));
+}
+function initChildren(formImpl) {
+  const childMap = new Map();
+  createSyncEffect(() => {
+    const {
+      base,
+      resolveChildren
+    } = formImpl;
+    const children = base.fields.children;
+    const kids = resolveChildren(formImpl);
+    const scope = base;
+    const detached = updateElements(children, () => kids.map(({
+      childKey,
+      create
+    }, childIndex) => {
+      let child = childMap.get(childKey);
+      if (child) {
+        child.fields.childIndex.value = childIndex;
+      } else {
+        var _cc$definition, _cc$parent;
+        const meta = {};
+        const cc = create(scope, meta);
+        const newOptions = {
+          forceHidden: false,
+          forceDisabled: false,
+          forceReadonly: false,
+          variables: combineVariables(formImpl.variables, cc.variables)
+        };
+        const fsChild = new FormStateNodeImpl(childKey, meta, (_cc$definition = cc.definition) != null ? _cc$definition : groupedControl([]), cc.node === undefined ? formImpl.form : cc.node, newOptions, formImpl.globals, (_cc$parent = cc.parent) != null ? _cc$parent : formImpl.parent, formImpl, childIndex, cc.resolveChildren);
+        child = fsChild.base;
+        childMap.set(childKey, child);
+      }
+      return child;
+    }));
+    detached.forEach(child => child.cleanup());
+  }, formImpl.base);
+}
+function visitFormState(node, visitFn) {
+  const v = visitFn(node);
+  if (v !== undefined) return v;
+  const childCount = node.getChildCount();
+  for (let i = 0; i < childCount; i++) {
+    const res = visitFormState(node.getChild(i), visitFn);
+    if (res !== undefined) return res;
+  }
+  return undefined;
+}
+
+function defaultResolveChildNodes(formStateNode) {
+  const {
+    resolved,
+    dataNode: data,
+    schemaInterface,
+    parent,
+    form: node
+  } = formStateNode;
+  if (!node) return [];
+  const def = resolved.definition;
+  if (isDataControl(def)) {
+    var _def$renderOptions;
+    if (!data) return [];
+    const type = (_def$renderOptions = def.renderOptions) == null ? void 0 : _def$renderOptions.type;
+    if (type === DataRenderType.CheckList || type === DataRenderType.Radio) {
+      const n = node.getChildNodes();
+      if (n.length > 0 && resolved.fieldOptions) {
+        return resolved.fieldOptions.map(x => {
+          var _x$value;
+          return {
+            childKey: (_x$value = x.value) == null ? void 0 : _x$value.toString(),
+            create: (scope, meta) => {
+              meta["fieldOptionValue"] = x.value;
+              const vars = createScopedComputed(scope, () => {
+                return {
+                  option: x,
+                  optionSelected: isOptionSelected(schemaInterface, x, data)
+                };
+              });
+              return {
+                definition: {
+                  type: ControlDefinitionType.Group,
+                  groupOptions: {
+                    type: GroupRenderType.Contents
+                  }
+                },
+                parent,
+                node,
+                variables: changes => ({
+                  formData: trackedValue(vars, changes)
+                })
+              };
+            }
+          };
+        });
+      }
+      return [];
+    }
+    if (data.schema.field.collection && data.elementIndex == null) return resolveArrayChildren(data, node);
+  }
+  return node.getChildNodes().map(x => ({
+    childKey: x.id,
+    create: () => ({
+      node: x,
+      parent: data != null ? data : parent,
+      definition: x.definition
+    })
+  }));
+}
+function resolveArrayChildren(data, node, adjustChild) {
+  const childNodes = node.getChildNodes();
+  const childCount = childNodes.length;
+  const singleChild = childCount === 1 ? childNodes[0] : null;
+  return data.control.as().elements.map((x, i) => ({
+    childKey: x.uniqueId + "/" + i,
+    create: () => {
+      var _adjustChild;
+      return _extends({
+        definition: !childCount ? {
+          type: ControlDefinitionType.Data,
+          field: ".",
+          hideTitle: true,
+          renderOptions: {
+            type: DataRenderType.Standard
+          }
+        } : singleChild ? singleChild.definition : groupedControl([]),
+        node: singleChild != null ? singleChild : node,
+        parent: data.getChildElement(i)
+      }, (_adjustChild = adjustChild == null ? void 0 : adjustChild(x, i)) != null ? _adjustChild : {});
+    }
+  }));
+}
+function isOptionSelected(schemaInterface, option, data) {
+  if (data.schema.field.collection) {
+    var _data$control$as$valu;
+    return !!((_data$control$as$valu = data.control.as().value) != null && _data$control$as$valu.includes(option.value));
+  }
+  return schemaInterface.compareValue(data.schema.field, data.control.value, option.value) === 0;
 }
-class NoValue {}
-const NoOverride = new NoValue();
 
-export { ActionStyle, AdornmentPlacement, ControlAdornmentType, ControlDefinitionType, DataRenderType, DateComparison, DefaultSchemaInterface, DisplayDataType, DynamicPropertyType, ExpressionType, FieldType, FormNode, FormTree, GroupRenderType, IconLibrary, IconPlacement, SchemaDataNode, SchemaDataTree, SchemaDataTreeImpl, SchemaNode, SchemaTags, SchemaTree, SyncTextType, ValidationMessageType, ValidatorType, addFieldOption, boolField, buildSchema, compoundField, createControlMap, createFormLookup, createFormState, createFormTree, createOverrideProxy, createSchemaDataNode, createSchemaLookup, createSchemaNode, createSchemaTree, createScoped, createScopedComputed, dateField, dateTimeField, defaultCompoundField, defaultScalarField, defaultSchemaInterface, doubleField, fieldPathForDefinition, findField, fontAwesomeIcon, getControlStateId, getDisplayOnlyOptions, getGroupRendererOptions, getJsonPath, getMetaFields, getRootDataNode, getSchemaFieldList, getSchemaNodePath, getSchemaNodePathString, getSchemaPath, getTagParam, hideDisplayOnly, intField, isActionControl, isArrayRenderer, isAutoCompleteClasses, isAutocompleteRenderer, isCheckEntryClasses, isCompoundField, isCompoundNode, isControlDisabled, isControlDisplayOnly, isControlReadonly, isDataControl, isDataGroupRenderer, isDateTimeRenderer, isDialogRenderer, isDisplayControl, isDisplayOnlyRenderer, isFlexRenderer, isGridRenderer, isGroupControl, isHtmlDisplay, isInlineRenderer, isScalarField, isSelectChildRenderer, isTabsRenderer, isTextDisplay, isTextfieldRenderer, isWizardRenderer, jsonPathString, legacyFormNode, lookupDataNode, makeCompoundField, makeParamTag, makeScalarField, makeSchemaDataNode, mergeField, mergeFields, mergeOption, missingField, relativePath, relativeSegmentPath, resolveSchemaNode, resolveSchemas, schemaDataForFieldPath, schemaDataForFieldRef, schemaForFieldPath, schemaForFieldRef, stringField, stringOptionsField, timeField, traverseData, traverseParents, traverseSchemaPath, validDataNode, visitControlData, visitControlDataArray, visitControlDefinition, visitFormData, visitFormDataInContext, visitFormDataNode, withScalarOptions };
+export { ActionStyle, AdornmentPlacement, ControlAdornmentType, ControlDefinitionType, ControlDisableType, DataRenderType, DateComparison, DefaultSchemaInterface, DisplayDataType, DynamicPropertyType, ExpressionType, FieldType, FormNode, FormTree, GroupRenderType, IconLibrary, IconPlacement, NoOverride, SchemaDataNode, SchemaDataTree, SchemaDataTreeImpl, SchemaNode, SchemaTags, SchemaTree, SyncTextType, ValidationMessageType, ValidatorType, accordionOptions, actionControl, addFieldOption, adornmentOptions, autocompleteOptions, boolField, buildSchema, checkListOptions, coerceString, coerceStyle, combineVariables, compoundControl, compoundField, createControlMap, createEvalExpr, createEvaluatedDefinition, createFormLookup, createFormStateNode, createFormTree, createOverrideProxy, createSchemaDataNode, createSchemaLookup, createSchemaNode, createSchemaTree, createScoped, createScopedComputed, dataControl, dataExpr, dataMatchExpr, dateField, dateTimeField, dateValidator$1 as dateValidator, dateValidatorOptions, defaultCompoundField, defaultEvaluators, defaultResolveChildNodes, defaultScalarField, defaultSchemaInterface, displayOnlyOptions, doubleField, dynamicDefaultValue, dynamicDisabled, dynamicReadonly, dynamicVisibility, emptyGroupDefinition, fieldEqExpr, fieldExpr, fieldPathForDefinition, findField, fontAwesomeIcon, getDisplayOnlyOptions, getGroupRendererOptions, getHasMoreControl, getJsonPath, getLoadingControl, getMetaFields, getParentDataPath, getRefreshingControl, getRootDataNode, getSchemaFieldList, getSchemaNodePath, getSchemaNodePathString, getSchemaPath, getTagParam, groupedControl, hideDisplayOnly, htmlDisplayControl, intField, isAccordionRenderer, isActionControl, isArrayRenderer, isAutoCompleteClasses, isAutocompleteRenderer, isCheckEntryClasses, isCompoundField, isCompoundNode, isControlDisabled, isControlDisplayOnly, isControlReadonly, isDataControl, isDataGroupRenderer, isDateTimeRenderer, isDialogRenderer, isDisplayControl, isDisplayOnlyRenderer, isFlexRenderer, isGridRenderer, isGroupControl, isHtmlDisplay, isInlineRenderer, isScalarField, isSelectChildRenderer, isTabsRenderer, isTextDisplay, isTextfieldRenderer, isWizardRenderer, jsonPathString, jsonataEval, jsonataExpr, jsonataOptions, jsonataValidator$1 as jsonataValidator, jsonataValidatorOptions, legacyFormNode, lengthValidator$1 as lengthValidator, lengthValidatorOptions, lookupDataNode, makeCompoundField, makeParamTag, makeScalarField, makeSchemaDataNode, mergeField, mergeFields, mergeOption, missingField, noopUi, notEmptyExpr, radioButtonOptions, relativePath, relativeSegmentPath, renderOptionsFor, resolveArrayChildren, resolveSchemaNode, resolveSchemas, schemaDataForFieldPath, schemaDataForFieldRef, schemaForDataPath, schemaForFieldPath, schemaForFieldRef, stringField, stringOptionsField, textDisplayControl, textfieldOptions, timeField, traverseData, traverseParents, traverseSchemaPath, uuidEval, uuidExpr, validDataNode, validatorOptions, visitControlData, visitControlDataArray, visitControlDefinition, visitFormData, visitFormDataInContext, visitFormState, withScalarOptions };
 //# sourceMappingURL=index.js.map