@astroapps/forms-core 1.0.1

package/lib/index.js

@@ -0,0 +1,1521 @@
+import { ensureMetaValue, newControl, updateComputedValue, addDependent, createSyncEffect, createAsyncEffect, collectChanges, trackedValue, createCleanupScope, createEffect, trackControlChange, ControlChange, createScopedEffect, getControlPath, unsafeRestoreControl, getCurrentFields } from '@astroapps/controls';
+import jsonata from 'jsonata';
+import { v4 } from 'uuid';
+
+var ControlDefinitionType;
+(function (ControlDefinitionType) {
+  ControlDefinitionType["Data"] = "Data";
+  ControlDefinitionType["Group"] = "Group";
+  ControlDefinitionType["Display"] = "Display";
+  ControlDefinitionType["Action"] = "Action";
+})(ControlDefinitionType || (ControlDefinitionType = {}));
+var DynamicPropertyType;
+(function (DynamicPropertyType) {
+  DynamicPropertyType["Visible"] = "Visible";
+  DynamicPropertyType["DefaultValue"] = "DefaultValue";
+  DynamicPropertyType["Readonly"] = "Readonly";
+  DynamicPropertyType["Disabled"] = "Disabled";
+  DynamicPropertyType["Display"] = "Display";
+  DynamicPropertyType["Style"] = "Style";
+  DynamicPropertyType["LayoutStyle"] = "LayoutStyle";
+  DynamicPropertyType["AllowedOptions"] = "AllowedOptions";
+  DynamicPropertyType["Label"] = "Label";
+  DynamicPropertyType["ActionData"] = "ActionData";
+})(DynamicPropertyType || (DynamicPropertyType = {}));
+var AdornmentPlacement;
+(function (AdornmentPlacement) {
+  AdornmentPlacement["ControlStart"] = "ControlStart";
+  AdornmentPlacement["ControlEnd"] = "ControlEnd";
+  AdornmentPlacement["LabelStart"] = "LabelStart";
+  AdornmentPlacement["LabelEnd"] = "LabelEnd";
+})(AdornmentPlacement || (AdornmentPlacement = {}));
+var ControlAdornmentType;
+(function (ControlAdornmentType) {
+  ControlAdornmentType["Tooltip"] = "Tooltip";
+  ControlAdornmentType["Accordion"] = "Accordion";
+  ControlAdornmentType["HelpText"] = "HelpText";
+  ControlAdornmentType["Icon"] = "Icon";
+  ControlAdornmentType["SetField"] = "SetField";
+  ControlAdornmentType["Optional"] = "Optional";
+})(ControlAdornmentType || (ControlAdornmentType = {}));
+var IconLibrary;
+(function (IconLibrary) {
+  IconLibrary["FontAwesome"] = "FontAwesome";
+  IconLibrary["Material"] = "Material";
+  IconLibrary["CssClass"] = "CssClass";
+})(IconLibrary || (IconLibrary = {}));
+var DataRenderType;
+(function (DataRenderType) {
+  DataRenderType["Standard"] = "Standard";
+  DataRenderType["Textfield"] = "Textfield";
+  DataRenderType["Radio"] = "Radio";
+  DataRenderType["HtmlEditor"] = "HtmlEditor";
+  DataRenderType["IconList"] = "IconList";
+  DataRenderType["CheckList"] = "CheckList";
+  DataRenderType["UserSelection"] = "UserSelection";
+  DataRenderType["Synchronised"] = "Synchronised";
+  DataRenderType["IconSelector"] = "IconSelector";
+  DataRenderType["DateTime"] = "DateTime";
+  DataRenderType["Checkbox"] = "Checkbox";
+  DataRenderType["Dropdown"] = "Dropdown";
+  DataRenderType["DisplayOnly"] = "DisplayOnly";
+  DataRenderType["Group"] = "Group";
+  DataRenderType["NullToggle"] = "NullToggle";
+  DataRenderType["Autocomplete"] = "Autocomplete";
+  DataRenderType["Jsonata"] = "Jsonata";
+  DataRenderType["Array"] = "Array";
+  DataRenderType["ArrayElement"] = "ArrayElement";
+  DataRenderType["ElementSelected"] = "ElementSelected";
+})(DataRenderType || (DataRenderType = {}));
+var SyncTextType;
+(function (SyncTextType) {
+  SyncTextType["Camel"] = "Camel";
+  SyncTextType["Snake"] = "Snake";
+  SyncTextType["Pascal"] = "Pascal";
+})(SyncTextType || (SyncTextType = {}));
+var GroupRenderType;
+(function (GroupRenderType) {
+  GroupRenderType["Standard"] = "Standard";
+  GroupRenderType["Grid"] = "Grid";
+  GroupRenderType["Flex"] = "Flex";
+  GroupRenderType["Tabs"] = "Tabs";
+  GroupRenderType["GroupElement"] = "GroupElement";
+  GroupRenderType["SelectChild"] = "SelectChild";
+  GroupRenderType["Inline"] = "Inline";
+  GroupRenderType["Wizard"] = "Wizard";
+  GroupRenderType["Dialog"] = "Dialog";
+  GroupRenderType["Contents"] = "Contents";
+})(GroupRenderType || (GroupRenderType = {}));
+var DisplayDataType;
+(function (DisplayDataType) {
+  DisplayDataType["Text"] = "Text";
+  DisplayDataType["Html"] = "Html";
+  DisplayDataType["Icon"] = "Icon";
+  DisplayDataType["Custom"] = "Custom";
+})(DisplayDataType || (DisplayDataType = {}));
+var ActionStyle;
+(function (ActionStyle) {
+  ActionStyle["Button"] = "Button";
+  ActionStyle["Secondary"] = "Secondary";
+  ActionStyle["Link"] = "Link";
+  ActionStyle["Group"] = "Group";
+})(ActionStyle || (ActionStyle = {}));
+var IconPlacement;
+(function (IconPlacement) {
+  IconPlacement["BeforeText"] = "BeforeText";
+  IconPlacement["AfterText"] = "AfterText";
+  IconPlacement["ReplaceText"] = "ReplaceText";
+})(IconPlacement || (IconPlacement = {}));
+function visitControlDefinition(x, visitor, defaultValue) {
+  switch (x.type) {
+    case ControlDefinitionType.Action:
+      return visitor.action(x);
+    case ControlDefinitionType.Data:
+      return visitor.data(x);
+    case ControlDefinitionType.Display:
+      return visitor.display(x);
+    case ControlDefinitionType.Group:
+      return visitor.group(x);
+    default:
+      return defaultValue(x);
+  }
+}
+function isGridRenderer(options) {
+  return options.type === GroupRenderType.Grid;
+}
+function isWizardRenderer(options) {
+  return options.type === GroupRenderType.Wizard;
+}
+function isDialogRenderer(options) {
+  return options.type === GroupRenderType.Dialog;
+}
+function isInlineRenderer(options) {
+  return options.type === GroupRenderType.Inline;
+}
+function isSelectChildRenderer(options) {
+  return options.type === GroupRenderType.SelectChild;
+}
+function isTabsRenderer(options) {
+  return options.type === GroupRenderType.Tabs;
+}
+function isFlexRenderer(options) {
+  return options.type === GroupRenderType.Flex;
+}
+function isDisplayOnlyRenderer(options) {
+  return options.type === DataRenderType.DisplayOnly;
+}
+function isTextfieldRenderer(options) {
+  return options.type === DataRenderType.Textfield;
+}
+function isDateTimeRenderer(options) {
+  return options.type === DataRenderType.DateTime;
+}
+function isAutocompleteRenderer(options) {
+  return options.type === DataRenderType.Autocomplete;
+}
+function isAutoCompleteClasses(options) {
+  switch (options == null ? void 0 : options.type) {
+    case DataRenderType.Autocomplete:
+      return true;
+    default:
+      return false;
+  }
+}
+function isDataGroupRenderer(options) {
+  return (options == null ? void 0 : options.type) === DataRenderType.Group;
+}
+function isArrayRenderer(options) {
+  return options.type === DataRenderType.Array;
+}
+function isDataControl(c) {
+  return c.type === ControlDefinitionType.Data;
+}
+function isGroupControl(c) {
+  return c.type === ControlDefinitionType.Group;
+}
+function isActionControl(c) {
+  return c.type === ControlDefinitionType.Action;
+}
+function isDisplayControl(c) {
+  return c.type === ControlDefinitionType.Display;
+}
+function isTextDisplay(d) {
+  return d.type === DisplayDataType.Text;
+}
+function isHtmlDisplay(d) {
+  return d.type === DisplayDataType.Html;
+}
+function isCheckEntryClasses(options) {
+  switch (options == null ? void 0 : options.type) {
+    case DataRenderType.Radio:
+    case DataRenderType.CheckList:
+      return true;
+    default:
+      return false;
+  }
+}
+function traverseParents(current, get, until) {
+  let outArray = [];
+  while (current && !(until != null && until(current))) {
+    outArray.push(get(current));
+    current = current.parent;
+  }
+  return outArray.reverse();
+}
+function getRootDataNode(dataNode) {
+  while (dataNode.parent) {
+    dataNode = dataNode.parent;
+  }
+  return dataNode;
+}
+function getJsonPath(dataNode) {
+  return traverseParents(dataNode, d => d.elementIndex == null ? d.schema.field.field : d.elementIndex, x => !x.parent);
+}
+function getSchemaPath(schemaNode) {
+  return traverseParents(schemaNode, d => d.field, x => !x.parent);
+}
+function getSchemaFieldList(schema) {
+  return schema.getChildNodes().map(x => x.field);
+}
+function fontAwesomeIcon(icon) {
+  return {
+    library: IconLibrary.FontAwesome,
+    name: icon
+  };
+}
+/**
+ * Checks if a control definition is readonly.
+ * @param c - The control definition to check.
+ * @returns True if the control definition is readonly, false otherwise.
+ */
+function isControlReadonly(c) {
+  return isDataControl(c) && !!c.readonly;
+}
+/**
+ * Checks if a control definition is disabled.
+ * @param c - The control definition to check.
+ * @returns True if the control definition is disabled, false otherwise.
+ */
+function isControlDisabled(c) {
+  return isDataControl(c) && !!c.disabled;
+}
+/**
+ * Returns the group renderer options for a control definition.
+ * @param {ControlDefinition} def - The control definition to get the group renderer options for.
+ * @returns {GroupRenderOptions | undefined} - The group renderer options, or undefined if not applicable.
+ */
+function getGroupRendererOptions(def) {
+  return isGroupControl(def) ? def.groupOptions : isDataControl(def) && isDataGroupRenderer(def.renderOptions) ? def.renderOptions.groupOptions : undefined;
+}
+/**
+ * Checks if a control definition is display-only.
+ * @param {ControlDefinition} def - The control definition to check.
+ * @returns {boolean} - True if the control definition is display-only, false otherwise.
+ */
+function isControlDisplayOnly(def) {
+  var _getGroupRendererOpti;
+  return Boolean((_getGroupRendererOpti = getGroupRendererOptions(def)) == null ? void 0 : _getGroupRendererOpti.displayOnly);
+}
+/**
+ * Returns the display-only render options for a control definition.
+ * @param d - The control definition to get the display-only render options for.
+ * @returns The display-only render options, or undefined if not applicable.
+ */
+function getDisplayOnlyOptions(d) {
+  return isDataControl(d) && d.renderOptions && isDisplayOnlyRenderer(d.renderOptions) ? d.renderOptions : undefined;
+}
+
+var ExpressionType;
+(function (ExpressionType) {
+  ExpressionType["Jsonata"] = "Jsonata";
+  ExpressionType["Data"] = "Data";
+  ExpressionType["DataMatch"] = "FieldValue";
+  ExpressionType["UserMatch"] = "UserMatch";
+  ExpressionType["NotEmpty"] = "NotEmpty";
+  ExpressionType["UUID"] = "UUID";
+})(ExpressionType || (ExpressionType = {}));
+
+/**
+ * Enum representing the various field types.
+ */
+var FieldType;
+(function (FieldType) {
+  FieldType["String"] = "String";
+  FieldType["Bool"] = "Bool";
+  FieldType["Int"] = "Int";
+  FieldType["Date"] = "Date";
+  FieldType["DateTime"] = "DateTime";
+  FieldType["Time"] = "Time";
+  FieldType["Double"] = "Double";
+  FieldType["EntityRef"] = "EntityRef";
+  FieldType["Compound"] = "Compound";
+  FieldType["AutoId"] = "AutoId";
+  FieldType["Image"] = "Image";
+  FieldType["Any"] = "Any";
+})(FieldType || (FieldType = {}));
+/**
+ * Enum representing the various validation message types.
+ */
+var ValidationMessageType;
+(function (ValidationMessageType) {
+  ValidationMessageType["NotEmpty"] = "NotEmpty";
+  ValidationMessageType["MinLength"] = "MinLength";
+  ValidationMessageType["MaxLength"] = "MaxLength";
+  ValidationMessageType["NotAfterDate"] = "NotAfterDate";
+  ValidationMessageType["NotBeforeDate"] = "NotBeforeDate";
+})(ValidationMessageType || (ValidationMessageType = {}));
+function findField(fields, field) {
+  return fields.find(x => x.field === field);
+}
+function isScalarField(sf) {
+  return !isCompoundField(sf);
+}
+function isCompoundField(sf) {
+  return sf.type === FieldType.Compound;
+}
+function missingField(field) {
+  return {
+    field: "__missing",
+    type: FieldType.Any,
+    displayName: field
+  };
+}
+var SchemaTags;
+(function (SchemaTags) {
+  SchemaTags["NoControl"] = "_NoControl";
+  SchemaTags["HtmlEditor"] = "_HtmlEditor";
+  SchemaTags["ControlGroup"] = "_ControlGroup:";
+  SchemaTags["ControlRef"] = "_ControlRef:";
+  SchemaTags["IdField"] = "_IdField:";
+})(SchemaTags || (SchemaTags = {}));
+function getTagParam(field, tag) {
+  var _field$tags;
+  return (_field$tags = field.tags) == null || (_field$tags = _field$tags.find(x => x.startsWith(tag))) == null ? void 0 : _field$tags.substring(tag.length);
+}
+function makeParamTag(tag, value) {
+  return `${tag}${value}`;
+}
+
+class SchemaTree {
+  createChildNode(parent, field) {
+    return new SchemaNode(parent.id + "/" + field.field, field, this, parent);
+  }
+  getSchema(schemaId) {
+    var _this$getSchemaTree;
+    return (_this$getSchemaTree = this.getSchemaTree(schemaId)) == null ? void 0 : _this$getSchemaTree.rootNode;
+  }
+}
+class SchemaTreeImpl extends SchemaTree {
+  getSchemaTree(schemaId) {
+    var _this$lookup;
+    return (_this$lookup = this.lookup) == null ? void 0 : _this$lookup.getSchemaTree(schemaId);
+  }
+  constructor(rootFields, lookup) {
+    super();
+    this.lookup = void 0;
+    this.rootNode = void 0;
+    this.lookup = lookup;
+    this.rootNode = new SchemaNode("", {
+      type: FieldType.Compound,
+      field: "",
+      children: rootFields
+    }, this);
+  }
+}
+function createSchemaTree(rootFields, lookup) {
+  return new SchemaTreeImpl(rootFields, lookup);
+}
+class SchemaNode {
+  constructor(id, field, tree, parent) {
+    this.id = void 0;
+    this.field = void 0;
+    this.tree = void 0;
+    this.parent = void 0;
+    this.id = id;
+    this.field = field;
+    this.tree = tree;
+    this.parent = parent;
+  }
+  getSchema(schemaId) {
+    return this.tree.getSchema(schemaId);
+  }
+  getUnresolvedFields() {
+    return isCompoundField(this.field) ? this.field.children : [];
+  }
+  getResolvedParent(noRecurse) {
+    var _this$parent;
+    const f = this.field;
+    if (!isCompoundField(f)) return undefined;
+    const parentNode = f.schemaRef ? this.tree.getSchema(f.schemaRef) : !noRecurse && f.treeChildren ? (_this$parent = this.parent) == null ? void 0 : _this$parent.getResolvedParent() : undefined;
+    return parentNode != null ? parentNode : this;
+  }
+  getResolvedFields() {
+    var _resolvedParent$getUn;
+    const resolvedParent = this.getResolvedParent();
+    return (_resolvedParent$getUn = resolvedParent == null ? void 0 : resolvedParent.getUnresolvedFields()) != null ? _resolvedParent$getUn : [];
+  }
+  getChildNodes() {
+    const node = this;
+    return node.getResolvedFields().map(x => node.createChildNode(x));
+  }
+  getChildField(field) {
+    var _this$getResolvedFiel;
+    return (_this$getResolvedFiel = this.getResolvedFields().find(x => x.field === field)) != null ? _this$getResolvedFiel : missingField(field);
+  }
+  createChildNode(field) {
+    return this.tree.createChildNode(this, field);
+  }
+  getChildNode(field) {
+    return this.createChildNode(this.getChildField(field));
+  }
+}
+function resolveSchemaNode(node, fieldSegment) {
+  if (fieldSegment == ".") return node;
+  if (fieldSegment == "..") return node.parent;
+  return node.getChildNode(fieldSegment);
+}
+function createSchemaNode(field, lookup, parent) {
+  return new SchemaNode(parent ? parent.id + "/" + field.field : field.field, field, lookup, parent);
+}
+function createSchemaLookup(schemaMap) {
+  const lookup = {
+    getSchemaTree,
+    getSchema
+  };
+  return lookup;
+  function getSchema(schemaId) {
+    return getSchemaTree(schemaId).rootNode;
+  }
+  function getSchemaTree(schemaId, additional) {
+    const fields = schemaMap[schemaId];
+    if (fields) {
+      return new SchemaTreeImpl(additional ? [...fields, ...additional] : fields, lookup);
+    }
+    return undefined;
+  }
+}
+function schemaForFieldRef(fieldRef, schema) {
+  var _fieldRef$split;
+  return schemaForFieldPath((_fieldRef$split = fieldRef == null ? void 0 : fieldRef.split("/")) != null ? _fieldRef$split : [], schema);
+}
+function traverseSchemaPath(fieldPath, schema, acc, next) {
+  let i = 0;
+  while (i < fieldPath.length) {
+    const nextField = fieldPath[i];
+    let childNode = resolveSchemaNode(schema, nextField);
+    if (!childNode) {
+      childNode = createSchemaNode(missingField(nextField), schema.tree, schema);
+    }
+    acc = next(acc, childNode);
+    schema = childNode;
+    i++;
+  }
+  return acc;
+}
+function traverseData(fieldPath, root, data) {
+  return traverseSchemaPath(fieldPath, root, data, (acc, n) => acc == null ? void 0 : acc[n.field.field]);
+}
+function schemaForFieldPath(fieldPath, schema) {
+  let i = 0;
+  while (i < fieldPath.length) {
+    const nextField = fieldPath[i];
+    let childNode = resolveSchemaNode(schema, nextField);
+    if (!childNode) {
+      childNode = createSchemaNode(missingField(nextField), schema.tree, schema);
+    }
+    schema = childNode;
+    i++;
+  }
+  return schema;
+}
+function getSchemaNodePath(node) {
+  const paths = [];
+  let curNode = node;
+  while (curNode) {
+    paths.push(curNode.field.field);
+    curNode = curNode.parent;
+  }
+  return paths.reverse();
+}
+function getSchemaNodePathString(node) {
+  return getSchemaNodePath(node).join("/");
+}
+function isCompoundNode(node) {
+  return isCompoundField(node.field);
+}
+/**
+ * Returns the relative path from a parent node to a child node.
+ * @param parent
+ * @param child
+ */
+function relativePath(parent, child) {
+  // return the path from child to parent
+  if (parent.id === child.id) return ".";
+  const parentPath = getSchemaNodePath(parent);
+  const childPath = getSchemaNodePath(child);
+  return relativeSegmentPath(parentPath, childPath);
+}
+/**
+ * Returns the relative path from a parent node to a child node.
+ * @param parentPath
+ * @param childPath
+ */
+function relativeSegmentPath(parentPath, childPath) {
+  let i = 0;
+  while (i < parentPath.length && i < childPath.length && parentPath[i] === childPath[i]) {
+    i++;
+  }
+  const upLevels = parentPath.length - i;
+  const downPath = childPath.slice(i).join("/");
+  return "../".repeat(upLevels) + downPath;
+}
+
+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]));
+}
+function stringField(displayName, options) {
+  return makeScalarField(_extends({
+    type: FieldType.String,
+    displayName
+  }, options));
+}
+function stringOptionsField(displayName, ...options) {
+  return makeScalarField({
+    type: FieldType.String,
+    displayName,
+    options
+  });
+}
+function withScalarOptions(options, v) {
+  return n => _extends({}, v(n), options);
+}
+function makeScalarField(options) {
+  return n => _extends({}, defaultScalarField(n, n), options);
+}
+function makeCompoundField(options) {
+  return n => _extends({}, defaultCompoundField(n, n, false), options);
+}
+function intField(displayName, options) {
+  return makeScalarField(_extends({
+    type: FieldType.Int,
+    displayName
+  }, options));
+}
+function doubleField(displayName, options) {
+  return makeScalarField(_extends({
+    type: FieldType.Double,
+    displayName
+  }, options));
+}
+function dateField(displayName, options) {
+  return makeScalarField(_extends({
+    type: FieldType.Date,
+    displayName
+  }, options));
+}
+function timeField(displayName, options) {
+  return makeScalarField(_extends({
+    type: FieldType.Time,
+    displayName
+  }, options));
+}
+function dateTimeField(displayName, options) {
+  return makeScalarField(_extends({
+    type: FieldType.DateTime,
+    displayName
+  }, options));
+}
+function boolField(displayName, options) {
+  return makeScalarField(_extends({
+    type: FieldType.Bool,
+    displayName
+  }, options));
+}
+function compoundField(displayName, fields, other) {
+  return field => _extends({}, defaultCompoundField(field, displayName, false), other, {
+    children: fields
+  });
+}
+function defaultScalarField(field, displayName) {
+  return {
+    field,
+    displayName,
+    type: FieldType.String
+  };
+}
+function defaultCompoundField(field, displayName, collection) {
+  return {
+    field,
+    displayName,
+    type: FieldType.Compound,
+    collection,
+    children: []
+  };
+}
+function mergeField(field, mergeInto) {
+  const existing = mergeInto.find(x => x.field === field.field);
+  if (existing) {
+    return mergeInto.map(x => x !== existing ? x : _extends({}, x, {
+      onlyForTypes: mergeTypes(x.onlyForTypes, field.onlyForTypes)
+    }));
+  }
+  return [...mergeInto, field];
+  function mergeTypes(f, s) {
+    if (!f) return s;
+    if (!s) return f;
+    const extras = s.filter(x => !f.includes(x));
+    return extras.length ? [...f, ...extras] : f;
+  }
+}
+function mergeFields(fields, name, value, newFields) {
+  const withType = fields.map(x => x.isTypeField ? addFieldOption(x, name, value) : x);
+  return newFields.map(x => _extends({}, x, {
+    onlyForTypes: [value]
+  })).reduce((af, x) => mergeField(x, af), withType);
+}
+function addFieldOption(typeField, name, value) {
+  var _typeField$options;
+  const options = (_typeField$options = typeField.options) != null ? _typeField$options : [];
+  if (options.some(x => x.value === value)) return typeField;
+  return _extends({}, typeField, {
+    options: [...options, {
+      name,
+      value
+    }]
+  });
+}
+function resolveSchemas(schemaMap) {
+  const out = {};
+  function resolveSchemaType(type) {
+    if (type in out) {
+      return out[type];
+    }
+    const resolvedFields = [];
+    out[type] = resolvedFields;
+    schemaMap[type].forEach(x => {
+      if (isCompoundField(x) && x.schemaRef) {
+        resolvedFields.push(_extends({}, x, {
+          children: resolveSchemaType(x.schemaRef)
+        }));
+      } else {
+        resolvedFields.push(x);
+      }
+    });
+    return resolvedFields;
+  }
+  Object.keys(schemaMap).forEach(resolveSchemaType);
+  return out;
+}
+
+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) {
+    this.id = void 0;
+    this.schema = void 0;
+    this.elementIndex = void 0;
+    this.control = void 0;
+    this.tree = void 0;
+    this.parent = void 0;
+    this.id = id;
+    this.schema = schema;
+    this.elementIndex = elementIndex;
+    this.control = control;
+    this.tree = tree;
+    this.parent = parent;
+  }
+  getChild(childNode) {
+    return this.tree.getChild(this, childNode);
+  }
+  getChildElement(elementIndex) {
+    return this.tree.getChildElement(this, elementIndex);
+  }
+}
+function getMetaFields(control) {
+  return ensureMetaValue(control, "metaFields", () => newControl({}));
+}
+class SchemaDataTreeImpl extends SchemaDataTree {
+  constructor(rootSchema, rootControl) {
+    super();
+    this.rootNode = void 0;
+    this.rootNode = new SchemaDataNode("", rootSchema, undefined, rootControl, this);
+  }
+  getChild(parent, childNode) {
+    let objControl = parent.control;
+    if (childNode.field.meta) {
+      objControl = getMetaFields(objControl);
+    }
+    const child = objControl.fields[childNode.field.field];
+    return new SchemaDataNode(child.uniqueId.toString(), childNode, undefined, child, this, parent);
+  }
+  getChildElement(parent, elementIndex) {
+    const elemControl = parent.control;
+    const elemChild = elemControl.elements[elementIndex];
+    return new SchemaDataNode(elemChild.uniqueId.toString(), parent.schema, elementIndex, elemChild, this, parent);
+  }
+}
+/**
+ * @deprecated Use createSchemaDataNode instead.
+ */
+const makeSchemaDataNode = createSchemaDataNode;
+function createSchemaDataNode(schema, control) {
+  return new SchemaDataTreeImpl(schema, control).rootNode;
+}
+function schemaDataForFieldRef(fieldRef, schema) {
+  var _fieldRef$split;
+  return schemaDataForFieldPath((_fieldRef$split = fieldRef == null ? void 0 : fieldRef.split("/")) != null ? _fieldRef$split : [], schema);
+}
+function schemaDataForFieldPath(fieldPath, dataNode) {
+  let i = 0;
+  while (i < fieldPath.length) {
+    var _nextNode;
+    const nextField = fieldPath[i];
+    let nextNode = nextField === ".." ? dataNode.parent : nextField === "." ? dataNode : lookupField(nextField);
+    (_nextNode = nextNode) != null ? _nextNode : nextNode = createSchemaDataNode(createSchemaNode(missingField(nextField), dataNode.schema.tree, dataNode.schema), newControl(undefined));
+    dataNode = nextNode;
+    i++;
+  }
+  return dataNode;
+  function lookupField(field) {
+    const childNode = resolveSchemaNode(dataNode.schema, field);
+    if (childNode) {
+      return dataNode.getChild(childNode);
+    }
+    return undefined;
+  }
+}
+function validDataNode(context) {
+  const parent = context.parent;
+  if (!parent) return true;
+  if (parent.schema.field.collection && parent.elementIndex == null) return validDataNode(parent);
+  return ensureMetaValue(context.control, "validForSchema", () => {
+    const c = newControl(true);
+    updateComputedValue(c, () => {
+      if (!validDataNode(parent)) return false;
+      const types = context.schema.field.onlyForTypes;
+      if (types == null || types.length === 0) return true;
+      const typeNode = parent.schema.getChildNodes().find(x => x.field.isTypeField);
+      if (typeNode == null) {
+        console.warn("No type field found for", parent.schema);
+        return false;
+      }
+      const typeField = parent.getChild(typeNode).control;
+      return typeField && types.includes(typeField.value);
+    });
+    return c;
+  }).value;
+}
+function hideDisplayOnly(context, schemaInterface, definition) {
+  var _context$control;
+  const displayOptions = getDisplayOnlyOptions(definition);
+  return displayOptions && !displayOptions.emptyText && schemaInterface.isEmptyValue(context.schema.field, (_context$control = context.control) == null ? void 0 : _context$control.value);
+}
+
+class DefaultSchemaInterface {
+  constructor(boolStrings = ["No", "Yes"], parseDateTime = s => Date.parse(s)) {
+    this.boolStrings = void 0;
+    this.parseDateTime = void 0;
+    this.boolStrings = boolStrings;
+    this.parseDateTime = parseDateTime;
+  }
+  parseToMillis(field, v) {
+    return this.parseDateTime(v);
+  }
+  validationMessageText(field, messageType, actual, expected) {
+    switch (messageType) {
+      case ValidationMessageType.NotEmpty:
+        return "Please enter a value";
+      case ValidationMessageType.MinLength:
+        return "Length must be at least " + expected;
+      case ValidationMessageType.MaxLength:
+        return "Length must be less than " + expected;
+      case ValidationMessageType.NotBeforeDate:
+        return `Date must not be before ${new Date(expected).toDateString()}`;
+      case ValidationMessageType.NotAfterDate:
+        return `Date must not be after ${new Date(expected).toDateString()}`;
+      default:
+        return "Unknown error";
+    }
+  }
+  getDataOptions(node) {
+    return this.getNodeOptions(node.schema);
+  }
+  getNodeOptions(node) {
+    return this.getOptions(node.field);
+  }
+  getOptions({
+    options
+  }) {
+    return options && options.length > 0 ? options : null;
+  }
+  getFilterOptions(array, field) {
+    return this.getNodeOptions(field);
+  }
+  isEmptyValue(f, value) {
+    if (f.collection) return Array.isArray(value) ? value.length === 0 : value == null;
+    switch (f.type) {
+      case FieldType.String:
+      case FieldType.DateTime:
+      case FieldType.Date:
+      case FieldType.Time:
+        return !value;
+      default:
+        return value == null;
+    }
+  }
+  searchText(field, value) {
+    var _this$textValue$toLow, _this$textValue;
+    return (_this$textValue$toLow = (_this$textValue = this.textValue(field, value)) == null ? void 0 : _this$textValue.toLowerCase()) != null ? _this$textValue$toLow : "";
+  }
+  textValueForData(dataNode) {
+    const options = this.getDataOptions(dataNode);
+    return this.textValue(dataNode.schema.field, dataNode.control.value, dataNode.elementIndex != null, options);
+  }
+  textValue(field, value, element, options) {
+    const actualOptions = options != null ? options : this.getOptions(field);
+    const option = actualOptions == null ? void 0 : actualOptions.find(x => x.value === value);
+    if (option) return option.name;
+    switch (field.type) {
+      case FieldType.Date:
+        return value ? new Date(value).toLocaleDateString() : undefined;
+      case FieldType.DateTime:
+        return value ? new Date(this.parseToMillis(field, value)).toLocaleString() : undefined;
+      case FieldType.Time:
+        return value ? new Date("1970-01-01T" + value).toLocaleTimeString() : undefined;
+      case FieldType.Bool:
+        return this.boolStrings[value ? 1 : 0];
+      default:
+        return value != null ? value.toString() : undefined;
+    }
+  }
+  controlLength(f, control) {
+    var _control$elements$len, _control$elements;
+    return f.collection ? (_control$elements$len = (_control$elements = control.elements) == null ? void 0 : _control$elements.length) != null ? _control$elements$len : 0 : this.valueLength(f, control.value);
+  }
+  valueLength(field, value) {
+    var _ref;
+    return (_ref = value && (value == null ? void 0 : value.length)) != null ? _ref : 0;
+  }
+  compareValue(field, v1, v2) {
+    if (v1 == null) return v2 == null ? 0 : 1;
+    if (v2 == null) return -1;
+    switch (field.type) {
+      case FieldType.Date:
+      case FieldType.DateTime:
+      case FieldType.Time:
+      case FieldType.String:
+        return v1.localeCompare(v2);
+      case FieldType.Bool:
+        return v1 ? v2 ? 0 : 1 : -1;
+      case FieldType.Int:
+      case FieldType.Double:
+        return v1 - v2;
+      default:
+        return 0;
+    }
+  }
+  compoundFieldSetup(f) {
+    return f.getChildNodes().map(x => {
+      const {
+        field
+      } = x.field;
+      return [field, this.makeControlSetup(x)];
+    });
+  }
+  compoundFieldEquality(f) {
+    return f.getChildNodes().map(x => {
+      const {
+        field
+      } = x.field;
+      return [field, (a, b) => this.makeEqualityFunc(x)(a[field], b[field])];
+    });
+  }
+  makeEqualityFunc(field, element) {
+    if (field.field.collection && !element) {
+      const elemEqual = this.makeEqualityFunc(field, true);
+      return (a, b) => {
+        if (a === b) return true;
+        if (a == null || b == null) return false;
+        if (a.length !== b.length) return false;
+        for (let i = 0; i < a.length; i++) {
+          if (!elemEqual(a[i], b[i])) return false;
+        }
+        return true;
+      };
+    }
+    switch (field.field.type) {
+      case FieldType.Compound:
+        const allChecks = this.compoundFieldEquality(field);
+        return (a, b) => a === b || a != null && b != null && allChecks.every(x => x[1](a, b));
+      default:
+        return (a, b) => a === b;
+    }
+  }
+  makeControlSetup(field, element) {
+    let setup = {
+      equals: this.makeEqualityFunc(field, element)
+    };
+    if (field.field.collection && !element) {
+      setup.elems = this.makeControlSetup(field, true);
+      return setup;
+    }
+    switch (field.field.type) {
+      case FieldType.Compound:
+        setup.fields = Object.fromEntries(this.compoundFieldSetup(field));
+    }
+    return setup;
+  }
+}
+const defaultSchemaInterface = new DefaultSchemaInterface();
+
+class FormNode {
+  constructor(id, definition, tree, parent) {
+    this.id = void 0;
+    this.definition = void 0;
+    this.tree = void 0;
+    this.parent = void 0;
+    this.id = id;
+    this.definition = definition;
+    this.tree = tree;
+    this.parent = parent;
+  }
+  visit(visitFn) {
+    const res = visitFn(this);
+    if (res !== undefined) return res;
+    const children = this.getUnresolvedChildNodes();
+    for (const child of children) {
+      const _res = child.visit(visitFn);
+      if (_res !== undefined) return _res;
+    }
+    return undefined;
+  }
+  getResolvedChildren() {
+    var _children, _ref;
+    const childRefId = this.definition.childRefId;
+    const parent = childRefId ? this.tree.getByRefId(childRefId) : undefined;
+    return (_children = (_ref = parent != null ? parent : this.definition) == null ? void 0 : _ref.children) != null ? _children : [];
+  }
+  createChildNode(childId, childDef) {
+    return new FormNode(this.tree.getChildId(this.id, childId, childDef), childDef, this.tree, this);
+  }
+  getChildNodes() {
+    const resolved = this.getResolvedChildren();
+    return resolved.map((x, i) => this.createChildNode(i.toString(), x));
+  }
+  getUnresolvedChildNodes() {
+    var _this$definition$chil, _this$definition$chil2;
+    return (_this$definition$chil = (_this$definition$chil2 = this.definition.children) == null ? void 0 : _this$definition$chil2.map((x, i) => this.createChildNode(i.toString(), x))) != null ? _this$definition$chil : [];
+  }
+}
+class FormTree {
+  getChildId(parentId, childId, control) {
+    return parentId + "/" + childId;
+  }
+}
+function getControlIds(definition) {
+  var _definition$children$, _definition$children;
+  const childEntries = (_definition$children$ = (_definition$children = definition.children) == null ? void 0 : _definition$children.flatMap(getControlIds)) != null ? _definition$children$ : [];
+  return !definition.id ? childEntries : [[definition.id, definition], ...childEntries];
+}
+function createControlMap(control) {
+  return Object.fromEntries(getControlIds(control));
+}
+class FormTreeImpl extends FormTree {
+  constructor(forms, root) {
+    super();
+    this.forms = void 0;
+    this.controlMap = void 0;
+    this.rootNode = void 0;
+    this.forms = forms;
+    this.rootNode = new FormNode("", root, this);
+    this.controlMap = createControlMap(root);
+  }
+  getByRefId(id) {
+    return this.controlMap[id];
+  }
+  getForm(formId) {
+    return this.forms.getForm(formId);
+  }
+}
+function legacyFormNode(definition) {
+  return createFormTree([definition]).rootNode.getChildNodes()[0];
+}
+function createFormTree(controls, getForm = {
+  getForm: () => undefined
+}) {
+  return new FormTreeImpl(getForm, {
+    type: ControlDefinitionType.Group,
+    children: controls,
+    groupOptions: {
+      type: GroupRenderType.Standard,
+      hideTitle: true
+    }
+  });
+}
+function createFormLookup(formMap) {
+  const lookup = {
+    getForm
+  };
+  const forms = Object.fromEntries(Object.entries(formMap).map(([k, v]) => [k, createFormTree(v, lookup)]));
+  return lookup;
+  function getForm(formId) {
+    return forms[formId];
+  }
+}
+function fieldPathForDefinition(c) {
+  const fieldName = isGroupControl(c) ? c.compoundField : isDataControl(c) ? c.field : undefined;
+  return fieldName == null ? void 0 : fieldName.split("/");
+}
+function lookupDataNode(c, parentNode) {
+  const fieldNamePath = fieldPathForDefinition(c);
+  return fieldNamePath ? schemaDataForFieldPath(fieldNamePath, parentNode) : undefined;
+}
+/**
+ * @deprecated use visitFormNodeData instead
+ */
+function visitControlDataArray(controls, context, cb) {
+  if (!controls) return undefined;
+  for (const c of controls) {
+    const r = visitControlData(c, context, cb);
+    if (r !== undefined) return r;
+  }
+  return undefined;
+}
+/**
+ * @deprecated use visitFormDataInContext instead
+ */
+function visitControlData(definition, ctx, cb) {
+  return visitFormDataInContext(ctx, legacyFormNode(definition), (n, d) => cb(d, n));
+}
+function visitFormData(node, dataNode, cb, notSelf) {
+  const def = node.definition;
+  const result = !notSelf && isDataControl(def) ? cb(dataNode, def) : undefined;
+  if (result !== undefined) return result;
+  if (dataNode.elementIndex == null && dataNode.schema.field.collection) {
+    const _l = dataNode.control.elements.length;
+    for (let i = 0; i < _l; i++) {
+      const elemChild = dataNode.getChildElement(i);
+      const elemResult = visitFormData(node, elemChild, cb);
+      if (elemResult !== undefined) return elemResult;
+    }
+    return undefined;
+  }
+  if (dataNode.control.isNull) return undefined;
+  const children = node.getChildNodes();
+  const l = children.length;
+  for (let i = 0; i < l; i++) {
+    const elemResult = visitFormDataInContext(dataNode, children[i], cb);
+    if (elemResult !== undefined) return elemResult;
+  }
+  return undefined;
+}
+function visitFormDataInContext(parentContext, node, cb) {
+  const dataNode = lookupDataNode(node.definition, parentContext);
+  return visitFormData(node, dataNode != null ? dataNode : parentContext, cb, !dataNode);
+}
+
+/**
+ * Converts a JSON path array to a string.
+ * @param jsonPath - The JSON path array to convert.
+ * @param customIndex - Optional function to customize the index format.
+ * @returns The JSON path string.
+ */
+function jsonPathString(jsonPath, customIndex) {
+  let out = "";
+  jsonPath.forEach((v, i) => {
+    if (typeof v === "number") {
+      var _customIndex;
+      out += (_customIndex = customIndex == null ? void 0 : customIndex(v)) != null ? _customIndex : "[" + v + "]";
+    } else {
+      if (i > 0) out += ".";
+      out += v;
+    }
+  });
+  return out;
+}
+function createScopedComputed(parent, compute) {
+  const c = newControl(undefined);
+  updateComputedValue(c, compute);
+  addDependent(parent, c);
+  return c.as();
+}
+function createScoped(parent, value, setup) {
+  const c = newControl(value, setup);
+  addDependent(parent, c);
+  return c;
+}
+
+const dataEval = (fvExpr, {
+  dataNode: node,
+  returnResult,
+  scope
+}) => {
+  createSyncEffect(() => {
+    var _otherField$control;
+    const otherField = schemaDataForFieldRef(fvExpr.field, node);
+    returnResult((_otherField$control = otherField.control) == null ? void 0 : _otherField$control.value);
+  }, scope);
+};
+const dataMatchEval = (matchExpr, {
+  dataNode,
+  returnResult,
+  scope
+}) => {
+  createSyncEffect(() => {
+    const otherField = schemaDataForFieldRef(matchExpr.field, dataNode);
+    const fv = otherField == null ? void 0 : otherField.control.value;
+    returnResult(Array.isArray(fv) ? fv.includes(matchExpr.value) : fv === matchExpr.value);
+  }, scope);
+};
+const notEmptyEval = (expr, {
+  returnResult,
+  dataNode,
+  scope,
+  schemaInterface
+}) => {
+  createSyncEffect(() => {
+    var _otherField$control2;
+    const otherField = schemaDataForFieldRef(expr.field, dataNode);
+    const fv = (_otherField$control2 = otherField.control) == null ? void 0 : _otherField$control2.value;
+    const field = otherField.schema.field;
+    const empty = !!expr.empty;
+    returnResult(field && empty === schemaInterface.isEmptyValue(field, fv));
+  }, scope);
+};
+const jsonataEval = (expr, {
+  scope,
+  returnResult,
+  dataNode,
+  variables
+}) => {
+  const path = getJsonPath(dataNode);
+  const pathString = jsonPathString(path, x => `#$i[${x}]`);
+  const rootData = getRootDataNode(dataNode).control;
+  const parsedJsonata = createScopedComputed(scope, () => {
+    const jExpr = expr.expression;
+    const fullExpr = pathString ? pathString + ".(" + jExpr + ")" : jExpr;
+    try {
+      return {
+        expr: jsonata(fullExpr ? fullExpr : "null"),
+        fullExpr
+      };
+    } catch (e) {
+      console.error(e);
+      return {
+        expr: jsonata("null"),
+        fullExpr
+      };
+    }
+  });
+  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);
+    collectChanges(effect.collectUsage, () => returnResult(evalResult));
+  }
+  createAsyncEffect(runJsonata, scope);
+};
+const uuidEval = (_, ctx) => {
+  ctx.returnResult(v4());
+};
+const defaultEvaluators = {
+  [ExpressionType.DataMatch]: dataMatchEval,
+  [ExpressionType.Data]: dataEval,
+  [ExpressionType.NotEmpty]: notEmptyEval,
+  [ExpressionType.Jsonata]: jsonataEval,
+  [ExpressionType.UUID]: uuidEval
+};
+
+const jsonataValidator = (validation, context) => {
+  const error = createScopedComputed(context, () => undefined);
+  jsonataEval({
+    type: ExpressionType.Jsonata,
+    expression: validation.expression
+  }, {
+    scope: error,
+    dataNode: context.parentData,
+    returnResult: v => {
+      trackControlChange(context.data.control, ControlChange.Validate);
+      console.log("Setting jsonata error", v);
+      context.data.control.setError("jsonata", v == null ? void 0 : v.toString());
+    },
+    schemaInterface: context.schemaInterface,
+    variables: context.formContext.fields.variables
+  });
+};
+const lengthValidator = (lv, context) => {
+  const {
+    schemaInterface
+  } = context;
+  context.addSync(() => {
+    const field = context.data.schema.field;
+    const control = context.data.control;
+    const len = schemaInterface.controlLength(field, control);
+    if (lv.min != null && len < lv.min) {
+      if (field != null && field.collection) {
+        control.setValue(v => Array.isArray(v) ? v.concat(Array.from({
+          length: lv.min - v.length
+        })) : Array.from({
+          length: lv.min
+        }));
+      } else {
+        return schemaInterface.validationMessageText(field, ValidationMessageType.MinLength, len, lv.min);
+      }
+    } else if (lv.max != null && len > lv.max) {
+      return schemaInterface.validationMessageText(field, ValidationMessageType.MaxLength, len, lv.max);
+    }
+    return undefined;
+  });
+};
+const dateValidator = (dv, context) => {
+  const {
+    schemaInterface
+  } = context;
+  const field = context.data.schema.field;
+  let comparisonDate;
+  if (dv.fixedDate) {
+    comparisonDate = schemaInterface.parseToMillis(field, dv.fixedDate);
+  } else {
+    const nowDate = new Date();
+    comparisonDate = Date.UTC(nowDate.getFullYear(), nowDate.getMonth(), nowDate.getDate());
+    if (dv.daysFromCurrent) {
+      comparisonDate += dv.daysFromCurrent * 86400000;
+    }
+  }
+  context.addSync(v => {
+    if (v) {
+      const selDate = schemaInterface.parseToMillis(field, v);
+      const notAfter = dv.comparison === DateComparison.NotAfter;
+      if (notAfter ? selDate > comparisonDate : selDate < comparisonDate) {
+        return schemaInterface.validationMessageText(field, notAfter ? ValidationMessageType.NotAfterDate : ValidationMessageType.NotBeforeDate, selDate, comparisonDate);
+      }
+    }
+    return null;
+  });
+};
+const defaultValidators = {
+  [ValidatorType.Jsonata]: jsonataValidator,
+  [ValidatorType.Length]: lengthValidator,
+  [ValidatorType.Date]: dateValidator
+};
+function createValidators(def, context) {
+  if (isDataControl(def)) {
+    var _def$validators;
+    const {
+      schemaInterface
+    } = 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;
+      });
+    }
+    (_def$validators = def.validators) == null || _def$validators.forEach(x => {
+      var _defaultValidators$x$;
+      return (_defaultValidators$x$ = defaultValidators[x.type]) == null ? void 0 : _defaultValidators$x$.call(defaultValidators, x, context);
+    });
+  }
+}
+function setupValidation(controlImpl, definition, dataNode, schemaInterface, parent, formNode) {
+  const validationEnabled = createScopedComputed(controlImpl, () => !definition.hidden);
+  const validatorsScope = createCleanupScope();
+  createEffect(() => {
+    validatorsScope.cleanup();
+    const dn = dataNode.value;
+    if (dn) {
+      let syncValidations = [];
+      createValidators(formNode.definition, {
+        data: dn,
+        parentData: parent,
+        validationEnabled,
+        schemaInterface,
+        addSync(validate) {
+          syncValidations.push(validate);
+        },
+        addCleanup(cleanup) {
+          validatorsScope.addCleanup(cleanup);
+        },
+        formContext: controlImpl
+      });
+      createEffect(() => {
+        if (!validationEnabled.value) return undefined;
+        trackControlChange(dn.control, ControlChange.Validate);
+        const value = dn.control.value;
+        let error = null;
+        for (const syncValidation of syncValidations) {
+          error = syncValidation(value);
+          if (error) break;
+        }
+        return error;
+      }, e => {
+        dn.control.setError("default", e);
+      }, validatorsScope);
+    }
+  }, c => {}, controlImpl);
+}
+
+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();
+    },
+    getControlState(parent, formNode, context) {
+      var _context$stateKey;
+      const stateId = parent.id + "$" + formNode.id + ((_context$stateKey = context.stateKey) != null ? _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
+          });
+          return true;
+        }
+        return false;
+      }
+      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 df = displayOverrides.fields;
+        createScopedEffect(c => {
+          const textDisplay = isDisplayControl(def) && isTextDisplay(def.displayData) ? def.displayData : undefined;
+          evalExpr(c, textDisplay == null ? void 0 : textDisplay.text, df.text, textDisplay && firstExpr(formNode, DynamicPropertyType.Display), coerceString);
+        }, displayOverrides);
+        createScopedEffect(c => {
+          const htmlDisplay = isDisplayControl(def) && isHtmlDisplay(def.displayData) ? def.displayData : undefined;
+          evalExpr(c, htmlDisplay == null ? void 0 : htmlDisplay.html, df.html, htmlDisplay && firstExpr(formNode, DynamicPropertyType.Display), coerceString);
+        }, displayOverrides);
+        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
+        });
+        const {
+          dataNode,
+          hidden,
+          readonly,
+          style,
+          layoutStyle,
+          allowedOptions,
+          disabled,
+          variables
+        } = 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);
+        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 || isControlDisabled(definition));
+        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);
+        setupValidation(controlImpl, definition, dataNode, schemaInterface, parent, formNode);
+        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;
+}
+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 : "";
+}
+function createScopedMetaValue(formNode, c, key, init) {
+  return ensureMetaValue(c, key, () => {
+    const holder = createScoped(c, undefined, {
+      equals: (a, b) => a === b
+    });
+    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;
+}
+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)) {
+        return overrides[p].value;
+      }
+      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);
+    }
+  });
+}
+
+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, 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, missingField, relativePath, relativeSegmentPath, resolveSchemaNode, resolveSchemas, schemaDataForFieldPath, schemaDataForFieldRef, schemaForFieldPath, schemaForFieldRef, stringField, stringOptionsField, timeField, traverseData, traverseParents, traverseSchemaPath, validDataNode, visitControlData, visitControlDataArray, visitControlDefinition, visitFormData, visitFormDataInContext, withScalarOptions };
+//# sourceMappingURL=index.js.map