@astroapps/forms-core 1.2.2 → 2.0.0

package/lib/index.cjs

@@ -25,6 +25,7 @@ exports.DynamicPropertyType = void 0;
   DynamicPropertyType["AllowedOptions"] = "AllowedOptions";
   DynamicPropertyType["Label"] = "Label";
   DynamicPropertyType["ActionData"] = "ActionData";
+  DynamicPropertyType["GridColumns"] = "GridColumns";
 })(exports.DynamicPropertyType || (exports.DynamicPropertyType = {}));
 exports.AdornmentPlacement = void 0;
 (function (AdornmentPlacement) {
@@ -70,6 +71,7 @@ exports.DataRenderType = void 0;
   DataRenderType["Array"] = "Array";
   DataRenderType["ArrayElement"] = "ArrayElement";
   DataRenderType["ElementSelected"] = "ElementSelected";
+  DataRenderType["ScrollList"] = "ScrollList";
 })(exports.DataRenderType || (exports.DataRenderType = {}));
 exports.SyncTextType = void 0;
 (function (SyncTextType) {
@@ -89,6 +91,7 @@ exports.GroupRenderType = void 0;
   GroupRenderType["Wizard"] = "Wizard";
   GroupRenderType["Dialog"] = "Dialog";
   GroupRenderType["Contents"] = "Contents";
+  GroupRenderType["Accordion"] = "Accordion";
 })(exports.GroupRenderType || (exports.GroupRenderType = {}));
 exports.DisplayDataType = void 0;
 (function (DisplayDataType) {
@@ -97,6 +100,12 @@ exports.DisplayDataType = void 0;
   DisplayDataType["Icon"] = "Icon";
   DisplayDataType["Custom"] = "Custom";
 })(exports.DisplayDataType || (exports.DisplayDataType = {}));
+exports.ControlDisableType = void 0;
+(function (ControlDisableType) {
+  ControlDisableType["None"] = "None";
+  ControlDisableType["Self"] = "Self";
+  ControlDisableType["Global"] = "Global";
+})(exports.ControlDisableType || (exports.ControlDisableType = {}));
 exports.ActionStyle = void 0;
 (function (ActionStyle) {
   ActionStyle["Button"] = "Button";
@@ -133,6 +142,9 @@ function isWizardRenderer(options) {
 function isDialogRenderer(options) {
   return options.type === exports.GroupRenderType.Dialog;
 }
+function isAccordionRenderer(options) {
+  return options.type === exports.GroupRenderType.Accordion;
+}
 function isInlineRenderer(options) {
   return options.type === exports.GroupRenderType.Inline;
 }
@@ -243,7 +255,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.
@@ -251,7 +263,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.
@@ -279,21 +291,22 @@ function getDisplayOnlyOptions(d) {
   return isDataControl(d) && d.renderOptions && isDisplayOnlyRenderer(d.renderOptions) ? d.renderOptions : undefined;
 }
 
-exports.ExpressionType = void 0;
-(function (ExpressionType) {
-  ExpressionType["Jsonata"] = "Jsonata";
-  ExpressionType["Data"] = "Data";
-  ExpressionType["DataMatch"] = "FieldValue";
-  ExpressionType["UserMatch"] = "UserMatch";
-  ExpressionType["NotEmpty"] = "NotEmpty";
-  ExpressionType["UUID"] = "UUID";
-})(exports.ExpressionType || (exports.ExpressionType = {}));
-
 function _arrayLikeToArray(r, a) {
   (null == a || a > r.length) && (a = r.length);
   for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
   return n;
 }
+function _defineProperties(e, r) {
+  for (var t = 0; t < r.length; t++) {
+    var o = r[t];
+    o.enumerable = o.enumerable || !1, o.configurable = !0, "value" in o && (o.writable = !0), Object.defineProperty(e, _toPropertyKey(o.key), o);
+  }
+}
+function _createClass(e, r, t) {
+  return r && _defineProperties(e.prototype, r), t && _defineProperties(e, t), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
 function _createForOfIteratorHelperLoose(r, e) {
   var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
   if (t) return (t = t.call(r)).next.bind(t);
@@ -328,6 +341,20 @@ function _setPrototypeOf(t, e) {
     return t.__proto__ = e, t;
   }, _setPrototypeOf(t, e);
 }
+function _toPrimitive(t, r) {
+  if ("object" != typeof t || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != typeof i) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+function _toPropertyKey(t) {
+  var i = _toPrimitive(t, "string");
+  return "symbol" == typeof i ? i : i + "";
+}
 function _unsupportedIterableToArray(r, a) {
   if (r) {
     if ("string" == typeof r) return _arrayLikeToArray(r, a);
@@ -336,6 +363,206 @@ function _unsupportedIterableToArray(r, a) {
   }
 }
 
+exports.ValidatorType = void 0;
+(function (ValidatorType) {
+  ValidatorType["Jsonata"] = "Jsonata";
+  ValidatorType["Date"] = "Date";
+  ValidatorType["Length"] = "Length";
+})(exports.ValidatorType || (exports.ValidatorType = {}));
+exports.DateComparison = void 0;
+(function (DateComparison) {
+  DateComparison["NotBefore"] = "NotBefore";
+  DateComparison["NotAfter"] = "NotAfter";
+})(exports.DateComparison || (exports.DateComparison = {}));
+function jsonataValidator$1(expr) {
+  return {
+    type: exports.ValidatorType.Jsonata,
+    expression: expr
+  };
+}
+function dateValidator$1(comparison, fixedDate, daysFromCurrent) {
+  return {
+    type: exports.ValidatorType.Date,
+    comparison: comparison,
+    fixedDate: fixedDate,
+    daysFromCurrent: daysFromCurrent
+  };
+}
+function lengthValidator$1(min, max) {
+  return {
+    type: exports.ValidatorType.Length,
+    min: min,
+    max: max
+  };
+}
+
+exports.ExpressionType = void 0;
+(function (ExpressionType) {
+  ExpressionType["Jsonata"] = "Jsonata";
+  ExpressionType["Data"] = "Data";
+  ExpressionType["DataMatch"] = "FieldValue";
+  ExpressionType["UserMatch"] = "UserMatch";
+  ExpressionType["NotEmpty"] = "NotEmpty";
+  ExpressionType["UUID"] = "UUID";
+})(exports.ExpressionType || (exports.ExpressionType = {}));
+
+function dataControl(field, title, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Data,
+    field: field,
+    title: title
+  }, options);
+}
+function validatorOptions(type) {
+  return function (o) {
+    return _extends({
+      type: type
+    }, o);
+  };
+}
+function adornmentOptions(type) {
+  return function (o) {
+    return _extends({
+      type: type
+    }, o);
+  };
+}
+function renderOptionsFor(type) {
+  return function (o) {
+    return {
+      renderOptions: _extends({
+        type: type
+      }, o)
+    };
+  };
+}
+var autocompleteOptions = renderOptionsFor(exports.DataRenderType.Autocomplete);
+var checkListOptions = renderOptionsFor(exports.DataRenderType.CheckList);
+var radioButtonOptions = renderOptionsFor(exports.DataRenderType.Radio);
+var lengthValidatorOptions = validatorOptions(exports.ValidatorType.Length);
+var jsonataValidatorOptions = validatorOptions(exports.ValidatorType.Jsonata);
+var dateValidatorOptions = validatorOptions(exports.ValidatorType.Date);
+var accordionOptions = adornmentOptions(exports.ControlAdornmentType.Accordion);
+var textfieldOptions = renderOptionsFor(exports.DataRenderType.Textfield);
+var displayOnlyOptions = renderOptionsFor(exports.DataRenderType.DisplayOnly);
+var jsonataOptions = renderOptionsFor(exports.DataRenderType.Jsonata);
+function textDisplayControl(text, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Display,
+    displayData: {
+      type: exports.DisplayDataType.Text,
+      text: text
+    }
+  }, options);
+}
+function htmlDisplayControl(html, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Display,
+    displayData: {
+      type: exports.DisplayDataType.Html,
+      html: html
+    }
+  }, options);
+}
+function dynamicDefaultValue(expr) {
+  return {
+    type: exports.DynamicPropertyType.DefaultValue,
+    expr: expr
+  };
+}
+function dynamicReadonly(expr) {
+  return {
+    type: exports.DynamicPropertyType.Readonly,
+    expr: expr
+  };
+}
+function dynamicVisibility(expr) {
+  return {
+    type: exports.DynamicPropertyType.Visible,
+    expr: expr
+  };
+}
+function dynamicDisabled(expr) {
+  return {
+    type: exports.DynamicPropertyType.Disabled,
+    expr: expr
+  };
+}
+function dataExpr(field) {
+  return {
+    type: exports.ExpressionType.Data,
+    field: field
+  };
+}
+/**
+ * @deprecated Use dataExpr
+ */
+var fieldExpr = dataExpr;
+/**
+ * @deprecated Use dataMatchExpr
+ */
+var fieldEqExpr = dataMatchExpr;
+var uuidExpr = {
+  type: exports.ExpressionType.UUID
+};
+function dataMatchExpr(field, value) {
+  return {
+    type: exports.ExpressionType.DataMatch,
+    field: field,
+    value: value
+  };
+}
+function notEmptyExpr(field, empty) {
+  return {
+    type: exports.ExpressionType.NotEmpty,
+    field: field,
+    empty: empty
+  };
+}
+function jsonataExpr(expression) {
+  return {
+    type: exports.ExpressionType.Jsonata,
+    expression: expression
+  };
+}
+function groupedControl(children, title, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Group,
+    children: children,
+    title: title,
+    groupOptions: {
+      type: "Standard",
+      hideTitle: !title
+    }
+  }, options);
+}
+function compoundControl(field, title, children, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Data,
+    field: field,
+    children: children,
+    title: title,
+    renderOptions: {
+      type: "Standard"
+    }
+  }, options);
+}
+function actionControl(actionText, actionId, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Action,
+    title: actionText,
+    actionId: actionId
+  }, options);
+}
+var emptyGroupDefinition = {
+  type: exports.ControlDefinitionType.Group,
+  children: [],
+  groupOptions: {
+    type: exports.GroupRenderType.Standard,
+    hideTitle: true
+  }
+};
+
 /**
  * Enum representing the various field types.
  */
@@ -439,21 +666,24 @@ function createSchemaTree(rootFields, lookup) {
   return new SchemaTreeImpl(rootFields, lookup);
 }
 var SchemaNode = /*#__PURE__*/function () {
-  function SchemaNode(id, field, tree, parent) {
+  function SchemaNode(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;
   }
   var _proto3 = SchemaNode.prototype;
   _proto3.getSchema = function getSchema(schemaId) {
     return this.tree.getSchema(schemaId);
   };
   _proto3.getUnresolvedFields = function getUnresolvedFields() {
+    if (this.getChildFields) return this.getChildFields();
     return isCompoundField(this.field) ? this.field.children : [];
   };
   _proto3.getResolvedParent = function getResolvedParent(noRecurse) {
@@ -549,6 +779,51 @@ function schemaForFieldPath(fieldPath, schema) {
   }
   return schema;
 }
+function schemaForDataPath(fieldPath, schema) {
+  var i = 0;
+  var element = schema.field.collection;
+  while (i < fieldPath.length) {
+    var nextField = fieldPath[i];
+    var childNode = void 0;
+    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(_ref) {
+  var node = _ref.node,
+    element = _ref.element;
+  if (element) return {
+    node: node,
+    element: false
+  };
+  var parent = node.parent;
+  return parent ? {
+    node: parent,
+    element: !!parent.field.collection
+  } : undefined;
+}
 function getSchemaNodePath(node) {
   var paths = [];
   var curNode = node;
@@ -710,6 +985,11 @@ function mergeOption(fields, name, value, fieldName) {
   });
 }
 function mergeFields(fields, name, value, newFields) {
+  if (name === "*") {
+    return newFields.reduce(function (af, x) {
+      return mergeField(x, af);
+    }, fields);
+  }
   var withType = fields.map(function (x) {
     return x.isTypeField ? addFieldOption(x, name, value) : x;
   });
@@ -757,18 +1037,6 @@ function resolveSchemas(schemaMap) {
   return out;
 }
 
-exports.ValidatorType = void 0;
-(function (ValidatorType) {
-  ValidatorType["Jsonata"] = "Jsonata";
-  ValidatorType["Date"] = "Date";
-  ValidatorType["Length"] = "Length";
-})(exports.ValidatorType || (exports.ValidatorType = {}));
-exports.DateComparison = void 0;
-(function (DateComparison) {
-  DateComparison["NotBefore"] = "NotBefore";
-  DateComparison["NotAfter"] = "NotAfter";
-})(exports.DateComparison || (exports.DateComparison = {}));
-
 var SchemaDataTree = function SchemaDataTree() {};
 var SchemaDataNode = /*#__PURE__*/function () {
   function SchemaDataNode(id, schema, elementIndex, control, tree, parent) {
@@ -820,7 +1088,7 @@ var SchemaDataTreeImpl = /*#__PURE__*/function (_SchemaDataTree) {
   _proto2.getChildElement = function getChildElement(parent, elementIndex) {
     var elemControl = parent.control;
     var elemChild = elemControl.elements[elementIndex];
-    return new SchemaDataNode(elemChild.uniqueId.toString(), parent.schema, elementIndex, elemChild, this, parent);
+    return new SchemaDataNode(elemChild.uniqueId.toString() + "_" + elementIndex, parent.schema, elementIndex, elemChild, this, parent);
   };
   return SchemaDataTreeImpl;
 }(SchemaDataTree);
@@ -882,6 +1150,21 @@ function hideDisplayOnly(context, schemaInterface, definition) {
   var 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 controls.ensureMetaValue(data, "loading", function () {
+    return controls.newControl(false);
+  });
+}
+function getRefreshingControl(data) {
+  return controls.ensureMetaValue(data, "refreshing", function () {
+    return controls.newControl(false);
+  });
+}
+function getHasMoreControl(data) {
+  return controls.ensureMetaValue(data, "hasMore", function () {
+    return controls.newControl(false);
+  });
+}
 
 var DefaultSchemaInterface = /*#__PURE__*/function () {
   function DefaultSchemaInterface(boolStrings, parseDateTime) {
@@ -965,7 +1248,7 @@ var DefaultSchemaInterface = /*#__PURE__*/function () {
       case exports.FieldType.Time:
         return value ? new Date("1970-01-01T" + value).toLocaleTimeString() : undefined;
       case exports.FieldType.Bool:
-        return this.boolStrings[value ? 1 : 0];
+        return value != null ? this.boolStrings[value ? 1 : 0] : undefined;
       default:
         return value != null ? value.toString() : undefined;
     }
@@ -975,8 +1258,8 @@ var DefaultSchemaInterface = /*#__PURE__*/function () {
     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);
   };
   _proto.valueLength = function valueLength(field, value) {
-    var _ref2;
-    return (_ref2 = value && (value == null ? void 0 : value.length)) != null ? _ref2 : 0;
+    var len = value == null ? void 0 : value.length;
+    return typeof len === "number" ? len : 0;
   };
   _proto.compareValue = function compareValue(field, v1, v2) {
     if (v1 == null) return v2 == null ? 0 : 1;
@@ -988,7 +1271,7 @@ var DefaultSchemaInterface = /*#__PURE__*/function () {
       case exports.FieldType.String:
         return v1.localeCompare(v2);
       case exports.FieldType.Bool:
-        return v1 ? v2 ? 0 : 1 : -1;
+        return v1 === v2 ? 0 : !v1 ? -1 : 1;
       case exports.FieldType.Int:
       case exports.FieldType.Double:
         return v1 - v2;
@@ -1145,7 +1428,7 @@ var FormTreeImpl = /*#__PURE__*/function (_FormTree) {
   return FormTreeImpl;
 }(FormTree);
 function legacyFormNode(definition) {
-  return createFormTree([definition]).rootNode.getChildNodes()[0];
+  return createFormTree([definition]).rootNode;
 }
 function createFormTree(controls, getForm) {
   if (getForm === void 0) {
@@ -1155,7 +1438,7 @@ function createFormTree(controls, getForm) {
       }
     };
   }
-  return new FormTreeImpl(getForm, {
+  return new FormTreeImpl(getForm, controls.length === 1 ? controls[0] : {
     type: exports.ControlDefinitionType.Group,
     children: controls,
     groupOptions: {
@@ -1232,35 +1515,6 @@ function visitFormDataInContext(parentContext, node, cb) {
   var dataNode = lookupDataNode(node.definition, parentContext);
   return visitFormData(node, dataNode != null ? dataNode : parentContext, cb, !dataNode);
 }
-function visitFormDataNode(node, visitFn) {
-  var dataNode = lookupDataNode(node.formNode.definition, node.parentData);
-  var v = visitFn(node, dataNode);
-  if (v !== undefined) return v;
-  var parentData = dataNode != null ? dataNode : node.parentData;
-  if (parentData.schema.field.collection && parentData.elementIndex == null) {
-    var elemCount = parentData.control.elements.length;
-    for (var i = 0; i < elemCount; i++) {
-      var _v = visitChildren(parentData.getChildElement(i));
-      if (_v !== undefined) return _v;
-    }
-    return undefined;
-  } else {
-    return visitChildren(parentData);
-  }
-  function visitChildren(parentData) {
-    var children = node.formNode.getChildNodes();
-    for (var _i2 = 0; _i2 < children.length; _i2++) {
-      var child = children[_i2];
-      var res = visitFormDataNode({
-        formNode: child,
-        parent: node,
-        parentData: parentData,
-        childIndex: _i2
-      }, visitFn);
-      if (res !== undefined) return res;
-    }
-  }
-}
 
 /**
  * Converts a JSON path array to a string.
@@ -1331,11 +1585,14 @@ var notEmptyEval = function notEmptyEval(expr, _ref3) {
 var jsonataEval = function jsonataEval(expr, _ref4) {
   var runJsonata = function runJsonata(effect, signal) {
     try {
-      var bindings = controls.collectChanges(effect.collectUsage, function () {
-        return variables == null ? void 0 : variables.value;
-      });
-      return Promise.resolve(parsedJsonata.fields.expr.value.evaluate(controls.trackedValue(rootData, effect.collectUsage), bindings)).then(function (evalResult) {
-        // console.log(parsedJsonata.fields.fullExpr.value, evalResult, bindings);
+      var trackedVars = variables == null ? void 0 : variables(effect.collectUsage);
+      return Promise.resolve(parsedJsonata.fields.expr.value.evaluate(controls.trackedValue(rootData, effect.collectUsage), trackedVars)).then(function (evalResult) {
+        // console.log(
+        //   rootData,
+        //   parsedJsonata.fields.fullExpr.current.value,
+        //   evalResult,
+        //   trackedVars,
+        // );
         controls.collectChanges(effect.collectUsage, function () {
           return returnResult(evalResult);
         });
@@ -1379,6 +1636,54 @@ var uuidEval = function uuidEval(_, ctx) {
   ctx.returnResult(uuid.v4());
 };
 var defaultEvaluators = (_defaultEvaluators = {}, _defaultEvaluators[exports.ExpressionType.DataMatch] = dataMatchEval, _defaultEvaluators[exports.ExpressionType.Data] = dataEval, _defaultEvaluators[exports.ExpressionType.NotEmpty] = notEmptyEval, _defaultEvaluators[exports.ExpressionType.Jsonata] = jsonataEval, _defaultEvaluators[exports.ExpressionType.UUID] = uuidEval, _defaultEvaluators);
+function createEvalExpr(evalExpression, context) {
+  function evalExpr(scope, init, nk, e, coerce) {
+    nk.value = init;
+    if (e != null && e.type) {
+      evalExpression(e, _extends({
+        returnResult: function returnResult(r) {
+          nk.value = coerce(r);
+        },
+        scope: scope
+      }, context));
+      return true;
+    }
+    return false;
+  }
+  return evalExpr;
+}
+
+function createOverrideProxy(proxyFor, handlers) {
+  var overrides = controls.getCurrentFields(handlers);
+  var allOwn = Reflect.ownKeys(proxyFor);
+  Reflect.ownKeys(overrides).forEach(function (k) {
+    if (!allOwn.includes(k)) allOwn.push(k);
+  });
+  return new Proxy(proxyFor, {
+    get: function get(target, p, receiver) {
+      if (Object.hasOwn(overrides, p)) {
+        var nv = overrides[p].value;
+        if (nv !== NoOverride) return nv;
+      }
+      return Reflect.get(target, p, receiver);
+    },
+    ownKeys: function ownKeys(target) {
+      return allOwn;
+    },
+    has: function has(target, p) {
+      return Reflect.has(proxyFor, p) || Reflect.has(overrides, p);
+    },
+    getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, k) {
+      if (Object.hasOwn(overrides, k)) return {
+        enumerable: true,
+        configurable: true
+      };
+      return Reflect.getOwnPropertyDescriptor(target, k);
+    }
+  });
+}
+var NoValue = function NoValue() {};
+var NoOverride = new NoValue();
 
 var _defaultValidators;
 var jsonataValidator = function jsonataValidator(validation, context) {
@@ -1397,7 +1702,7 @@ var jsonataValidator = function 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
   });
 };
@@ -1457,7 +1762,7 @@ function createValidators(def, context) {
     if (def.required) {
       context.addSync(function (v) {
         var field = context.data.schema.field;
-        return schemaInterface.isEmptyValue(field, v) ? schemaInterface.validationMessageText(field, exports.ValidationMessageType.NotEmpty, false, true) : null;
+        return schemaInterface.isEmptyValue(field, v) ? def.requiredErrorText ? def.requiredErrorText : schemaInterface.validationMessageText(field, exports.ValidationMessageType.NotEmpty, false, true) : null;
       });
     }
     (_def$validators = def.validators) == null || _def$validators.forEach(function (x) {
@@ -1466,9 +1771,9 @@ function createValidators(def, context) {
     });
   }
 }
-function setupValidation(controlImpl, definition, dataNode, schemaInterface, parent, formNode, hidden, runAsync) {
-  var validationEnabled = createScopedComputed(controlImpl, function () {
-    return !hidden.value;
+function setupValidation(scope, variables, definition, dataNode, schemaInterface, parent, visible, runAsync) {
+  var validationEnabled = createScopedComputed(scope, function () {
+    return !!visible.value;
   });
   var validatorsScope = controls.createCleanupScope();
   controls.createEffect(function () {
@@ -1476,7 +1781,7 @@ function setupValidation(controlImpl, definition, dataNode, schemaInterface, par
     var dn = dataNode.value;
     if (dn) {
       var syncValidations = [];
-      createValidators(formNode.definition, {
+      createValidators(definition, {
         data: dn,
         parentData: parent,
         validationEnabled: validationEnabled,
@@ -1487,7 +1792,7 @@ function setupValidation(controlImpl, definition, dataNode, schemaInterface, par
         addCleanup: function addCleanup(cleanup) {
           validatorsScope.addCleanup(cleanup);
         },
-        formContext: controlImpl,
+        variables: variables,
         runAsync: runAsync
       });
       controls.createEffect(function () {
@@ -1505,289 +1810,643 @@ function setupValidation(controlImpl, definition, dataNode, schemaInterface, par
         dn.control.setError("default", e);
       }, validatorsScope);
     }
-  }, function (c) {}, controlImpl);
+  }, function (c) {}, scope);
 }
 
-function getControlStateId(parent, formNode, stateKey) {
-  return parent.id + "$" + formNode.id + (stateKey != null ? stateKey : "");
+function createEvaluatedDefinition(def, evalExpr, scope, display) {
+  var definitionOverrides = createScoped(scope, {});
+  var displayOverrides = createScoped(scope, {});
+  var groupOptionsOverrides = createScoped(scope, {});
+  var renderOptionsOverrides = createScoped(scope, {});
+  var _definitionOverrides$ = definitionOverrides.fields,
+    hidden = _definitionOverrides$.hidden,
+    displayData = _definitionOverrides$.displayData,
+    readonly = _definitionOverrides$.readonly,
+    disabled = _definitionOverrides$.disabled,
+    defaultValue = _definitionOverrides$.defaultValue,
+    actionData = _definitionOverrides$.actionData,
+    title = _definitionOverrides$.title,
+    groupOptions = _definitionOverrides$.groupOptions,
+    renderOptions = _definitionOverrides$.renderOptions;
+  var columns = groupOptionsOverrides.fields.columns;
+  var dataGroupRenderOptions = renderOptionsOverrides.fields.groupOptions;
+  var _displayOverrides$fie = displayOverrides.fields,
+    html = _displayOverrides$fie.html,
+    text = _displayOverrides$fie.text;
+  controls.updateComputedValue(dataGroupRenderOptions, function () {
+    var _def$renderOptions$gr;
+    return isDataControl(def) && isDataGroupRenderer(def.renderOptions) ? createOverrideProxy((_def$renderOptions$gr = def.renderOptions.groupOptions) != null ? _def$renderOptions$gr : {}, groupOptionsOverrides) : undefined;
+  });
+  controls.updateComputedValue(displayData, function () {
+    return isDisplayControl(def) ? createOverrideProxy(def.displayData, displayOverrides) : undefined;
+  });
+  controls.updateComputedValue(groupOptions, function () {
+    var groupOptions = getGroupRendererOptions(def);
+    return groupOptions ? createOverrideProxy(groupOptions, groupOptionsOverrides) : undefined;
+  });
+  controls.updateComputedValue(renderOptions, function () {
+    var _def$renderOptions;
+    return isDataControl(def) ? createOverrideProxy((_def$renderOptions = def.renderOptions) != null ? _def$renderOptions : {}, renderOptionsOverrides) : undefined;
+  });
+  evalDynamic(hidden, exports.DynamicPropertyType.Visible,
+  // Make sure it's not null if no scripting
+  function (x) {
+    return x ? def.hidden : !!def.hidden;
+  }, function (r) {
+    return !r;
+  });
+  evalDynamic(readonly, exports.DynamicPropertyType.Readonly, function () {
+    return isControlReadonly(def);
+  }, function (r) {
+    return !!r;
+  });
+  controls.createScopedEffect(function (c) {
+    evalExpr(c, isControlDisabled(def), disabled, firstExpr(exports.DynamicPropertyType.Disabled), function (r) {
+      return !!r;
+    });
+  }, definitionOverrides);
+  controls.createScopedEffect(function (c) {
+    var groupOptions = getGroupRendererOptions(def);
+    evalExpr(c, groupOptions == null ? void 0 : groupOptions.columns, columns, groupOptions ? firstExpr(exports.DynamicPropertyType.GridColumns) : undefined, function (r) {
+      return typeof r === "number" ? r : undefined;
+    });
+  }, groupOptionsOverrides);
+  controls.createScopedEffect(function (c) {
+    evalExpr(c, isDataControl(def) ? def.defaultValue : undefined, defaultValue, isDataControl(def) ? firstExpr(exports.DynamicPropertyType.DefaultValue) : undefined, function (r) {
+      return r;
+    });
+  }, definitionOverrides);
+  controls.createScopedEffect(function (c) {
+    evalExpr(c, isActionControl(def) ? def.actionData : undefined, actionData, isActionControl(def) ? firstExpr(exports.DynamicPropertyType.ActionData) : undefined, function (r) {
+      return r;
+    });
+  }, definitionOverrides);
+  controls.createScopedEffect(function (c) {
+    evalExpr(c, def.title, title, firstExpr(exports.DynamicPropertyType.Label), coerceString);
+  }, definitionOverrides);
+  controls.createSyncEffect(function () {
+    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);
+  return createOverrideProxy(def, definitionOverrides);
+  function firstExpr(property) {
+    var _def$dynamic;
+    return (_def$dynamic = def.dynamic) == null || (_def$dynamic = _def$dynamic.find(function (x) {
+      return x.type === property && x.expr.type;
+    })) == null ? void 0 : _def$dynamic.expr;
+  }
+  function evalDynamic(control, property, init, coerce) {
+    controls.createScopedEffect(function (c) {
+      var x = firstExpr(property);
+      evalExpr(c, init(x), control, x, coerce);
+    }, scope);
+  }
+}
+function coerceStyle(v) {
+  return typeof v === "object" ? v : undefined;
 }
-function createFormState(schemaInterface, evaluators) {
-  if (evaluators === void 0) {
-    evaluators = defaultEvaluators;
+function coerceString(v) {
+  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);
   }
-  // console.log("createFormState");
-  var controlStates = controls.newControl({});
-  function evalExpression(e, context) {
-    var x = evaluators[e.type];
-    x == null || x(e, context);
+}
+function createFormStateNode(formNode, parent, options, nodeOptions) {
+  var globals = controls.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);
+}
+var noopUi = {
+  ensureChildVisible: function ensureChildVisible(childIndex) {},
+  ensureVisible: function ensureVisible() {},
+  getDisabler: function getDisabler(type) {
+    return function () {
+      return function () {};
+    };
   }
-  return {
-    evalExpression: evalExpression,
-    cleanup: function cleanup() {
-      // console.log("Cleanup form state");
-      controlStates.cleanup();
-    },
-    getExistingControlState: function getExistingControlState(parent, formNode, stateKey) {
-      var stateId = getControlStateId(parent, formNode, stateKey);
-      var control = controls.getCurrentFields(controlStates)[stateId];
-      if (control) {
-        var _getMetaValue;
-        return (_getMetaValue = controls.getMetaValue(control, "impl")) == null ? void 0 : _getMetaValue.value;
-      }
-      return undefined;
-    },
-    getControlState: function getControlState(parent, formNode, context, runAsync) {
-      var stateId = getControlStateId(parent, formNode, context.stateKey);
-      var 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: function returnResult(r) {
-              nk.value = coerce(r);
-            },
-            scope: scope,
-            dataNode: parent,
-            variables: controlImpl.fields.variables,
-            schemaInterface: schemaInterface,
-            runAsync: runAsync
-          });
-          return true;
+};
+var FormStateNodeImpl = /*#__PURE__*/function () {
+  function FormStateNodeImpl(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;
+    var base = controls.newControl({
+      readonly: false,
+      visible: null,
+      disabled: false,
+      children: [],
+      resolved: {
+        definition: definition
+      },
+      parent: parent,
+      allowedOptions: undefined,
+      childIndex: childIndex,
+      nodeOptions: nodeOptions,
+      busy: false
+    }, {
+      dontClearError: true
+    });
+    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);
+  }
+  var _proto = FormStateNodeImpl.prototype;
+  _proto.setBusy = function setBusy(busy) {
+    this.base.fields.busy.value = busy;
+  };
+  _proto.setForceDisabled = function setForceDisabled(value) {
+    return this.options.fields.forceDisabled.value = value;
+  };
+  _proto.attachUi = function attachUi(f) {
+    this.ui = f;
+  };
+  _proto.setTouched = function setTouched(touched, notChildren) {
+    this.base.setTouched(touched, notChildren);
+  };
+  _proto.validate = function validate() {
+    this.children.forEach(function (child) {
+      child.validate();
+    });
+    if (this.dataNode) {
+      this.dataNode.control.validate();
+    }
+    return this.valid;
+  };
+  _proto.getChild = function 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"];
+  };
+  _proto.getChildCount = function getChildCount() {
+    return this.base.fields.children.elements.length;
+  };
+  _proto.cleanup = function cleanup() {
+    this.base.cleanup();
+  };
+  _proto.ensureMeta = function ensureMeta(key, init) {
+    if (key in this.meta) return this.meta[key];
+    var res = init(this.base);
+    this.meta[key] = res;
+    return res;
+  };
+  return _createClass(FormStateNodeImpl, [{
+    key: "busy",
+    get: function get() {
+      return this.base.fields.busy.value;
+    }
+  }, {
+    key: "evalExpression",
+    get: function get() {
+      return this.globals.fields.evalExpression.value;
+    }
+  }, {
+    key: "runAsync",
+    get: function get() {
+      return this.globals.fields.runAsync.value;
+    }
+  }, {
+    key: "schemaInterface",
+    get: function get() {
+      return this.globals.fields.schemaInterface.value;
+    }
+  }, {
+    key: "forceDisabled",
+    get: function get() {
+      return this.options.fields.forceDisabled.value;
+    }
+  }, {
+    key: "forceReadonly",
+    get: function get() {
+      return this.options.fields.forceReadonly.value;
+    }
+  }, {
+    key: "forceHidden",
+    get: function get() {
+      return this.options.fields.forceHidden.value;
+    }
+  }, {
+    key: "childIndex",
+    get: function get() {
+      return this.base.fields.childIndex.value;
+    }
+  }, {
+    key: "children",
+    get: function get() {
+      return this.base.fields.children.elements.map(function (x) {
+        return x.meta["$FormState"];
+      });
+    }
+  }, {
+    key: "uniqueId",
+    get: function get() {
+      return this.base.uniqueId.toString();
+    }
+  }, {
+    key: "valid",
+    get: function get() {
+      return this.base.valid;
+    }
+  }, {
+    key: "touched",
+    get: function get() {
+      return this.base.touched;
+    }
+  }, {
+    key: "readonly",
+    get: function get() {
+      return this.base.fields.readonly.value;
+    }
+  }, {
+    key: "visible",
+    get: function get() {
+      return this.base.fields.visible.value;
+    }
+  }, {
+    key: "disabled",
+    get: function get() {
+      return this.base.fields.disabled.value;
+    }
+  }, {
+    key: "clearHidden",
+    get: function get() {
+      return this.globals.fields.clearHidden.value;
+    }
+  }, {
+    key: "variables",
+    get: function get() {
+      return this.options.fields.variables.value;
+    }
+  }, {
+    key: "definition",
+    get: function get() {
+      return this.resolved.definition;
+    }
+  }, {
+    key: "resolved",
+    get: function get() {
+      return this.base.fields.resolved.value;
+    }
+  }, {
+    key: "dataNode",
+    get: function get() {
+      return this.base.fields.dataNode.value;
+    }
+  }]);
+}();
+function initFormState(def, impl, parentNode) {
+  var base = impl.base,
+    options = impl.options,
+    schemaInterface = impl.schemaInterface,
+    runAsync = impl.runAsync,
+    evalExpression = impl.evalExpression,
+    parent = impl.parent,
+    variables = impl.variables;
+  var evalExpr = createEvalExpr(evalExpression, {
+    schemaInterface: schemaInterface,
+    variables: variables,
+    dataNode: parent,
+    runAsync: runAsync
+  });
+  var scope = base;
+  var _options$fields = options.fields,
+    forceReadonly = _options$fields.forceReadonly,
+    forceDisabled = _options$fields.forceDisabled,
+    forceHidden = _options$fields.forceHidden;
+  var resolved = base.fields.resolved.as();
+  var _resolved$fields = resolved.fields,
+    style = _resolved$fields.style,
+    layoutStyle = _resolved$fields.layoutStyle,
+    fieldOptions = _resolved$fields.fieldOptions,
+    display = _resolved$fields.display,
+    rd = _resolved$fields.definition;
+  evalDynamic(display, exports.DynamicPropertyType.Display, undefined, coerceString);
+  var _base$fields = base.fields,
+    dataNode = _base$fields.dataNode,
+    readonly = _base$fields.readonly,
+    disabled = _base$fields.disabled,
+    visible = _base$fields.visible,
+    allowedOptions = _base$fields.allowedOptions;
+  var definition = createEvaluatedDefinition(def, evalExpr, scope, display);
+  rd.value = definition;
+  evalDynamic(style, exports.DynamicPropertyType.Style, undefined, coerceStyle);
+  evalDynamic(layoutStyle, exports.DynamicPropertyType.LayoutStyle, undefined, coerceStyle);
+  evalDynamic(allowedOptions, exports.DynamicPropertyType.AllowedOptions, undefined, function (x) {
+    return x;
+  });
+  controls.updateComputedValue(dataNode, function () {
+    return lookupDataNode(definition, parent);
+  });
+  controls.updateComputedValue(visible, function () {
+    if (forceHidden.value) return false;
+    if (parentNode && !parentNode.visible) return parentNode.visible;
+    var dn = dataNode.value;
+    if (dn && (!validDataNode(dn) || hideDisplayOnly(dn, schemaInterface, definition))) return false;
+    return definition.hidden == null ? null : !definition.hidden;
+  });
+  controls.updateComputedValue(readonly, function () {
+    return (parentNode == null ? void 0 : parentNode.readonly) || forceReadonly.value || isControlReadonly(definition);
+  });
+  controls.updateComputedValue(disabled, function () {
+    return (parentNode == null ? void 0 : parentNode.disabled) || forceDisabled.value || isControlDisabled(definition);
+  });
+  controls.updateComputedValue(fieldOptions, function () {
+    var _allowedOptions$value;
+    var dn = dataNode.value;
+    if (!dn) return undefined;
+    var fieldOptions = schemaInterface.getDataOptions(dn);
+    var _allowed = (_allowedOptions$value = allowedOptions.value) != null ? _allowedOptions$value : [];
+    var allowed = Array.isArray(_allowed) ? _allowed : [_allowed];
+    return allowed.length > 0 ? allowed.map(function (x) {
+      var _fieldOptions$find;
+      return typeof x === "object" ? x : (_fieldOptions$find = fieldOptions == null ? void 0 : fieldOptions.find(function (y) {
+        return y.value == x;
+      })) != null ? _fieldOptions$find : {
+        name: x.toString(),
+        value: x
+      };
+    }).filter(function (x) {
+      return x != null;
+    }) : fieldOptions;
+  });
+  controls.createSyncEffect(function () {
+    var dn = dataNode.value;
+    if (dn) {
+      dn.control.disabled = disabled.value;
+    }
+  }, scope);
+  controls.createSyncEffect(function () {
+    var dn = dataNode.value;
+    if (dn) {
+      dn.control.touched = base.touched;
+    }
+  }, scope);
+  controls.createSyncEffect(function () {
+    var dn = dataNode.value;
+    if (dn) {
+      base.touched = dn.control.touched;
+    }
+  }, scope);
+  controls.createSyncEffect(function () {
+    var dn = dataNode.value;
+    base.setErrors(dn == null ? void 0 : dn.control.errors);
+  }, scope);
+  setupValidation(scope, impl.variables, definition, dataNode, schemaInterface, parent, visible, runAsync);
+  controls.createSyncEffect(function () {
+    var _dataNode$value;
+    var 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;
         }
-        return false;
+      } else if (impl.visible && dn.value === undefined && definition.defaultValue != null && !((_definition$adornment = definition.adornments) != null && _definition$adornment.some(function (x) {
+        return x.type === exports.ControlAdornmentType.Optional;
+      })) && ((_definition$renderOpt = definition.renderOptions) == null ? void 0 : _definition$renderOpt.type) != exports.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;
       }
-      return createScopedMetaValue(formNode, controlImpl, "impl", function (scope) {
-        var _controlImpl$fields$v;
-        var cf = controlImpl.fields;
-        var definitionOverrides = createScoped(controlImpl, {});
-        createScoped(controlImpl, undefined);
-        var displayOverrides = createScoped(controlImpl, {});
-        var def = formNode.definition;
-        var definition = createOverrideProxy(def, definitionOverrides);
-        var of = definitionOverrides.fields;
-        var _displayOverrides$fie = displayOverrides.fields,
-          text = _displayOverrides$fie.text,
-          html = _displayOverrides$fie.html;
-        controls.updateComputedValue(of.displayData, function () {
-          return isDisplayControl(def) ? createOverrideProxy(def.displayData, displayOverrides) : undefined;
-        });
-        controls.createScopedEffect(function (c) {
-          evalExpr(c, def.hidden, of.hidden, firstExpr(formNode, exports.DynamicPropertyType.Visible), function (r) {
-            return !r;
-          });
-        }, definitionOverrides);
-        controls.createScopedEffect(function (c) {
-          evalExpr(c, isControlReadonly(def), of.readonly, firstExpr(formNode, exports.DynamicPropertyType.Readonly), function (r) {
-            return !!r;
-          });
-        }, definitionOverrides);
-        controls.createScopedEffect(function (c) {
-          evalExpr(c, isControlDisabled(def), of.disabled, firstExpr(formNode, exports.DynamicPropertyType.Disabled), function (r) {
-            return !!r;
-          });
-        }, definitionOverrides);
-        controls.createScopedEffect(function (c) {
-          evalExpr(c, isDataControl(def) ? def.defaultValue : undefined, of.defaultValue, isDataControl(def) ? firstExpr(formNode, exports.DynamicPropertyType.DefaultValue) : undefined, function (r) {
-            return r;
-          });
-        }, definitionOverrides);
-        controls.createScopedEffect(function (c) {
-          evalExpr(c, isActionControl(def) ? def.actionData : undefined, of.actionData, isActionControl(def) ? firstExpr(formNode, exports.DynamicPropertyType.ActionData) : undefined, function (r) {
-            return r;
-          });
-        }, definitionOverrides);
-        controls.createScopedEffect(function (c) {
-          evalExpr(c, def.title, of.title, firstExpr(formNode, exports.DynamicPropertyType.Label), coerceString);
-        }, definitionOverrides);
-        var control = createScoped(controlImpl, {
-          definition: definition,
-          dataNode: undefined,
-          schemaInterface: schemaInterface,
-          disabled: false,
-          readonly: false,
-          clearHidden: false,
-          hidden: false,
-          variables: (_controlImpl$fields$v = controlImpl.fields.variables.current.value) != null ? _controlImpl$fields$v : {},
-          stateId: stateId,
-          meta: controls.newControl({})
-        });
-        var _control$fields = control.fields,
-          dataNode = _control$fields.dataNode,
-          hidden = _control$fields.hidden,
-          readonly = _control$fields.readonly,
-          style = _control$fields.style,
-          layoutStyle = _control$fields.layoutStyle,
-          allowedOptions = _control$fields.allowedOptions,
-          disabled = _control$fields.disabled,
-          variables = _control$fields.variables,
-          display = _control$fields.display;
-        controls.createScopedEffect(function (c) {
-          return evalExpr(c, undefined, style, firstExpr(formNode, exports.DynamicPropertyType.Style), coerceStyle);
-        }, scope);
-        controls.createScopedEffect(function (c) {
-          return evalExpr(c, undefined, layoutStyle, firstExpr(formNode, exports.DynamicPropertyType.LayoutStyle), coerceStyle);
-        }, scope);
-        controls.createScopedEffect(function (c) {
-          return evalExpr(c, undefined, allowedOptions, firstExpr(formNode, exports.DynamicPropertyType.AllowedOptions), function (x) {
-            return x;
-          });
-        }, scope);
-        controls.createScopedEffect(function (c) {
-          return evalExpr(c, undefined, display, firstExpr(formNode, exports.DynamicPropertyType.Display), coerceString);
-        }, scope);
-        controls.updateComputedValue(dataNode, function () {
-          return lookupDataNode(definition, parent);
-        });
-        controls.updateComputedValue(hidden, function () {
-          return !!cf.hidden.value || definition.hidden || dataNode.value && (!validDataNode(dataNode.value) || hideDisplayOnly(dataNode.value, schemaInterface, definition));
-        });
-        controls.updateComputedValue(readonly, function () {
-          return !!cf.readonly.value || isControlReadonly(definition);
-        });
-        controls.updateComputedValue(disabled, function () {
-          return !!cf.disabled.value || of.disabled.value;
-        });
-        controls.updateComputedValue(variables, function () {
-          var _controlImpl$fields$v2;
-          return (_controlImpl$fields$v2 = controlImpl.fields.variables.value) != null ? _controlImpl$fields$v2 : {};
-        });
-        controls.createSyncEffect(function () {
-          var dn = dataNode.value;
-          if (dn) {
-            dn.control.disabled = disabled.value;
-          }
-        }, scope);
-        controls.createSyncEffect(function () {
-          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);
-        controls.createSyncEffect(function () {
-          var _dataNode$value;
-          var 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(function (x) {
-              return x.type === exports.ControlAdornmentType.Optional;
-            })) && ((_definition$renderOpt = definition.renderOptions) == null ? void 0 : _definition$renderOpt.type) != exports.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);
-      });
     }
+  }, scope);
+  initChildren(impl);
+  function firstExpr(property) {
+    var _def$dynamic2;
+    return (_def$dynamic2 = def.dynamic) == null || (_def$dynamic2 = _def$dynamic2.find(function (x) {
+      return x.type === property && x.expr.type;
+    })) == null ? void 0 : _def$dynamic2.expr;
+  }
+  function evalDynamic(control, property, init, coerce) {
+    controls.createScopedEffect(function (c) {
+      return evalExpr(c, init, control, firstExpr(property), coerce);
+    }, scope);
+  }
+}
+function combineVariables(v1, v2) {
+  if (!v1) return v2;
+  if (!v2) return v1;
+  return function (c) {
+    return _extends({}, v1(c), v2(c));
   };
 }
-function firstExpr(formNode, property) {
-  var _formNode$definition$;
-  return (_formNode$definition$ = formNode.definition.dynamic) == null || (_formNode$definition$ = _formNode$definition$.find(function (x) {
-    return x.type === property && x.expr.type;
-  })) == null ? void 0 : _formNode$definition$.expr;
+function initChildren(formImpl) {
+  var childMap = new Map();
+  controls.createSyncEffect(function () {
+    var base = formImpl.base,
+      resolveChildren = formImpl.resolveChildren;
+    var children = base.fields.children;
+    var kids = resolveChildren(formImpl);
+    var scope = base;
+    var detached = controls.updateElements(children, function () {
+      return kids.map(function (_ref, childIndex) {
+        var childKey = _ref.childKey,
+          create = _ref.create;
+        var child = childMap.get(childKey);
+        if (child) {
+          child.fields.childIndex.value = childIndex;
+        } else {
+          var _cc$definition, _cc$parent;
+          var meta = {};
+          var cc = create(scope, meta);
+          var newOptions = {
+            forceHidden: false,
+            forceDisabled: false,
+            forceReadonly: false,
+            variables: combineVariables(formImpl.variables, cc.variables)
+          };
+          var 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(function (child) {
+      return child.cleanup();
+    });
+  }, formImpl.base);
 }
-function coerceStyle(v) {
-  return typeof v === "object" ? v : undefined;
+function visitFormState(node, visitFn) {
+  var v = visitFn(node);
+  if (v !== undefined) return v;
+  var childCount = node.getChildCount();
+  for (var i = 0; i < childCount; i++) {
+    var res = visitFormState(node.getChild(i), visitFn);
+    if (res !== undefined) return res;
+  }
+  return undefined;
 }
-function coerceString(v) {
-  var _v$toString;
-  return typeof v === "string" ? v : (_v$toString = v == null ? void 0 : v.toString()) != null ? _v$toString : "";
-}
-function createScopedMetaValue(formNode, c, key, init) {
-  return controls.ensureMetaValue(c, key, function () {
-    var holder = createScoped(c, undefined, {
-      equals: function equals(a, b) {
-        return a === b;
+
+function defaultResolveChildNodes(formStateNode) {
+  var resolved = formStateNode.resolved,
+    data = formStateNode.dataNode,
+    schemaInterface = formStateNode.schemaInterface,
+    parent = formStateNode.parent,
+    node = formStateNode.form;
+  if (!node) return [];
+  var def = resolved.definition;
+  if (isDataControl(def)) {
+    var _def$renderOptions;
+    if (!data) return [];
+    var type = (_def$renderOptions = def.renderOptions) == null ? void 0 : _def$renderOptions.type;
+    if (type === exports.DataRenderType.CheckList || type === exports.DataRenderType.Radio) {
+      var n = node.getChildNodes();
+      if (n.length > 0 && resolved.fieldOptions) {
+        return resolved.fieldOptions.map(function (x) {
+          var _x$value;
+          return {
+            childKey: (_x$value = x.value) == null ? void 0 : _x$value.toString(),
+            create: function create(scope, meta) {
+              meta["fieldOptionValue"] = x.value;
+              var vars = createScopedComputed(scope, function () {
+                return {
+                  option: x,
+                  optionSelected: isOptionSelected(schemaInterface, x, data)
+                };
+              });
+              return {
+                definition: {
+                  type: exports.ControlDefinitionType.Group,
+                  groupOptions: {
+                    type: exports.GroupRenderType.Contents
+                  }
+                },
+                parent: parent,
+                node: node,
+                variables: function variables(changes) {
+                  return {
+                    formData: controls.trackedValue(vars, changes)
+                  };
+                }
+              };
+            }
+          };
+        });
+      }
+      return [];
+    }
+    if (data.schema.field.collection && data.elementIndex == null) return resolveArrayChildren(data, node);
+  }
+  return node.getChildNodes().map(function (x) {
+    return {
+      childKey: x.id,
+      create: function create() {
+        return {
+          node: x,
+          parent: data != null ? data : parent,
+          definition: x.definition
+        };
       }
-    });
-    var effect = controls.createScopedEffect(function (c) {
-      return holder.value = init(c);
-    }, holder);
-    effect.run = function () {
-      console.log("ControlState being recreated:", effect.subscriptions.map(function (x) {
-        var _x$;
-        return ((_x$ = x[1]) == null ? void 0 : _x$.mask) + " " + jsonPathString(controls.getControlPath(x[0], controls.unsafeRestoreControl(formNode.definition)));
-      }));
     };
-    return holder;
-  }).value;
-}
-function createOverrideProxy(proxyFor, handlers) {
-  var overrides = controls.getCurrentFields(handlers);
-  var allOwn = Reflect.ownKeys(proxyFor);
-  Reflect.ownKeys(overrides).forEach(function (k) {
-    if (!allOwn.includes(k)) allOwn.push(k);
   });
-  return new Proxy(proxyFor, {
-    get: function get(target, p, receiver) {
-      if (Object.hasOwn(overrides, p)) {
-        var nv = overrides[p].value;
-        if (nv !== NoOverride) return nv;
+}
+function resolveArrayChildren(data, node, adjustChild) {
+  var childNodes = node.getChildNodes();
+  var childCount = childNodes.length;
+  var singleChild = childCount === 1 ? childNodes[0] : null;
+  return data.control.as().elements.map(function (x, i) {
+    return {
+      childKey: x.uniqueId,
+      create: function create() {
+        var _adjustChild;
+        return _extends({
+          definition: !childCount ? {
+            type: exports.ControlDefinitionType.Data,
+            field: ".",
+            hideTitle: true,
+            renderOptions: {
+              type: exports.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 : {});
       }
-      return Reflect.get(target, p, receiver);
-    },
-    ownKeys: function ownKeys(target) {
-      return allOwn;
-    },
-    has: function has(target, p) {
-      return Reflect.has(proxyFor, p) || Reflect.has(overrides, p);
-    },
-    getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, k) {
-      if (Object.hasOwn(overrides, k)) return {
-        enumerable: true,
-        configurable: true
-      };
-      return Reflect.getOwnPropertyDescriptor(target, k);
-    }
+    };
   });
 }
-var NoValue = function NoValue() {};
-var NoOverride = new NoValue();
+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;
+}
 
 exports.DefaultSchemaInterface = DefaultSchemaInterface;
 exports.FormNode = FormNode;
 exports.FormTree = FormTree;
+exports.NoOverride = NoOverride;
 exports.SchemaDataNode = SchemaDataNode;
 exports.SchemaDataTree = SchemaDataTree;
 exports.SchemaDataTreeImpl = SchemaDataTreeImpl;
 exports.SchemaNode = SchemaNode;
 exports.SchemaTree = SchemaTree;
+exports.accordionOptions = accordionOptions;
+exports.actionControl = actionControl;
 exports.addFieldOption = addFieldOption;
+exports.adornmentOptions = adornmentOptions;
+exports.autocompleteOptions = autocompleteOptions;
 exports.boolField = boolField;
 exports.buildSchema = buildSchema;
+exports.checkListOptions = checkListOptions;
+exports.coerceString = coerceString;
+exports.coerceStyle = coerceStyle;
+exports.combineVariables = combineVariables;
+exports.compoundControl = compoundControl;
 exports.compoundField = compoundField;
 exports.createControlMap = createControlMap;
+exports.createEvalExpr = createEvalExpr;
+exports.createEvaluatedDefinition = createEvaluatedDefinition;
 exports.createFormLookup = createFormLookup;
-exports.createFormState = createFormState;
+exports.createFormStateNode = createFormStateNode;
 exports.createFormTree = createFormTree;
 exports.createOverrideProxy = createOverrideProxy;
 exports.createSchemaDataNode = createSchemaDataNode;
@@ -1796,28 +2455,49 @@ exports.createSchemaNode = createSchemaNode;
 exports.createSchemaTree = createSchemaTree;
 exports.createScoped = createScoped;
 exports.createScopedComputed = createScopedComputed;
+exports.dataControl = dataControl;
+exports.dataExpr = dataExpr;
+exports.dataMatchExpr = dataMatchExpr;
 exports.dateField = dateField;
 exports.dateTimeField = dateTimeField;
+exports.dateValidator = dateValidator$1;
+exports.dateValidatorOptions = dateValidatorOptions;
 exports.defaultCompoundField = defaultCompoundField;
+exports.defaultEvaluators = defaultEvaluators;
+exports.defaultResolveChildNodes = defaultResolveChildNodes;
 exports.defaultScalarField = defaultScalarField;
 exports.defaultSchemaInterface = defaultSchemaInterface;
+exports.displayOnlyOptions = displayOnlyOptions;
 exports.doubleField = doubleField;
+exports.dynamicDefaultValue = dynamicDefaultValue;
+exports.dynamicDisabled = dynamicDisabled;
+exports.dynamicReadonly = dynamicReadonly;
+exports.dynamicVisibility = dynamicVisibility;
+exports.emptyGroupDefinition = emptyGroupDefinition;
+exports.fieldEqExpr = fieldEqExpr;
+exports.fieldExpr = fieldExpr;
 exports.fieldPathForDefinition = fieldPathForDefinition;
 exports.findField = findField;
 exports.fontAwesomeIcon = fontAwesomeIcon;
-exports.getControlStateId = getControlStateId;
 exports.getDisplayOnlyOptions = getDisplayOnlyOptions;
 exports.getGroupRendererOptions = getGroupRendererOptions;
+exports.getHasMoreControl = getHasMoreControl;
 exports.getJsonPath = getJsonPath;
+exports.getLoadingControl = getLoadingControl;
 exports.getMetaFields = getMetaFields;
+exports.getParentDataPath = getParentDataPath;
+exports.getRefreshingControl = getRefreshingControl;
 exports.getRootDataNode = getRootDataNode;
 exports.getSchemaFieldList = getSchemaFieldList;
 exports.getSchemaNodePath = getSchemaNodePath;
 exports.getSchemaNodePathString = getSchemaNodePathString;
 exports.getSchemaPath = getSchemaPath;
 exports.getTagParam = getTagParam;
+exports.groupedControl = groupedControl;
 exports.hideDisplayOnly = hideDisplayOnly;
+exports.htmlDisplayControl = htmlDisplayControl;
 exports.intField = intField;
+exports.isAccordionRenderer = isAccordionRenderer;
 exports.isActionControl = isActionControl;
 exports.isArrayRenderer = isArrayRenderer;
 exports.isAutoCompleteClasses = isAutoCompleteClasses;
@@ -1846,7 +2526,14 @@ exports.isTextDisplay = isTextDisplay;
 exports.isTextfieldRenderer = isTextfieldRenderer;
 exports.isWizardRenderer = isWizardRenderer;
 exports.jsonPathString = jsonPathString;
+exports.jsonataEval = jsonataEval;
+exports.jsonataExpr = jsonataExpr;
+exports.jsonataOptions = jsonataOptions;
+exports.jsonataValidator = jsonataValidator$1;
+exports.jsonataValidatorOptions = jsonataValidatorOptions;
 exports.legacyFormNode = legacyFormNode;
+exports.lengthValidator = lengthValidator$1;
+exports.lengthValidatorOptions = lengthValidatorOptions;
 exports.lookupDataNode = lookupDataNode;
 exports.makeCompoundField = makeCompoundField;
 exports.makeParamTag = makeParamTag;
@@ -1856,26 +2543,37 @@ exports.mergeField = mergeField;
 exports.mergeFields = mergeFields;
 exports.mergeOption = mergeOption;
 exports.missingField = missingField;
+exports.noopUi = noopUi;
+exports.notEmptyExpr = notEmptyExpr;
+exports.radioButtonOptions = radioButtonOptions;
 exports.relativePath = relativePath;
 exports.relativeSegmentPath = relativeSegmentPath;
+exports.renderOptionsFor = renderOptionsFor;
+exports.resolveArrayChildren = resolveArrayChildren;
 exports.resolveSchemaNode = resolveSchemaNode;
 exports.resolveSchemas = resolveSchemas;
 exports.schemaDataForFieldPath = schemaDataForFieldPath;
 exports.schemaDataForFieldRef = schemaDataForFieldRef;
+exports.schemaForDataPath = schemaForDataPath;
 exports.schemaForFieldPath = schemaForFieldPath;
 exports.schemaForFieldRef = schemaForFieldRef;
 exports.stringField = stringField;
 exports.stringOptionsField = stringOptionsField;
+exports.textDisplayControl = textDisplayControl;
+exports.textfieldOptions = textfieldOptions;
 exports.timeField = timeField;
 exports.traverseData = traverseData;
 exports.traverseParents = traverseParents;
 exports.traverseSchemaPath = traverseSchemaPath;
+exports.uuidEval = uuidEval;
+exports.uuidExpr = uuidExpr;
 exports.validDataNode = validDataNode;
+exports.validatorOptions = validatorOptions;
 exports.visitControlData = visitControlData;
 exports.visitControlDataArray = visitControlDataArray;
 exports.visitControlDefinition = visitControlDefinition;
 exports.visitFormData = visitFormData;
 exports.visitFormDataInContext = visitFormDataInContext;
-exports.visitFormDataNode = visitFormDataNode;
+exports.visitFormState = visitFormState;
 exports.withScalarOptions = withScalarOptions;
 //# sourceMappingURL=index.cjs.map