@astroapps/forms-core 1.0.1

package/lib/index.cjs

@@ -0,0 +1,1813 @@
+var controls = require('@astroapps/controls');
+var jsonata = require('jsonata');
+var uuid = require('uuid');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var jsonata__default = /*#__PURE__*/_interopDefaultLegacy(jsonata);
+
+exports.ControlDefinitionType = void 0;
+(function (ControlDefinitionType) {
+  ControlDefinitionType["Data"] = "Data";
+  ControlDefinitionType["Group"] = "Group";
+  ControlDefinitionType["Display"] = "Display";
+  ControlDefinitionType["Action"] = "Action";
+})(exports.ControlDefinitionType || (exports.ControlDefinitionType = {}));
+exports.DynamicPropertyType = void 0;
+(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";
+})(exports.DynamicPropertyType || (exports.DynamicPropertyType = {}));
+exports.AdornmentPlacement = void 0;
+(function (AdornmentPlacement) {
+  AdornmentPlacement["ControlStart"] = "ControlStart";
+  AdornmentPlacement["ControlEnd"] = "ControlEnd";
+  AdornmentPlacement["LabelStart"] = "LabelStart";
+  AdornmentPlacement["LabelEnd"] = "LabelEnd";
+})(exports.AdornmentPlacement || (exports.AdornmentPlacement = {}));
+exports.ControlAdornmentType = void 0;
+(function (ControlAdornmentType) {
+  ControlAdornmentType["Tooltip"] = "Tooltip";
+  ControlAdornmentType["Accordion"] = "Accordion";
+  ControlAdornmentType["HelpText"] = "HelpText";
+  ControlAdornmentType["Icon"] = "Icon";
+  ControlAdornmentType["SetField"] = "SetField";
+  ControlAdornmentType["Optional"] = "Optional";
+})(exports.ControlAdornmentType || (exports.ControlAdornmentType = {}));
+exports.IconLibrary = void 0;
+(function (IconLibrary) {
+  IconLibrary["FontAwesome"] = "FontAwesome";
+  IconLibrary["Material"] = "Material";
+  IconLibrary["CssClass"] = "CssClass";
+})(exports.IconLibrary || (exports.IconLibrary = {}));
+exports.DataRenderType = void 0;
+(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";
+})(exports.DataRenderType || (exports.DataRenderType = {}));
+exports.SyncTextType = void 0;
+(function (SyncTextType) {
+  SyncTextType["Camel"] = "Camel";
+  SyncTextType["Snake"] = "Snake";
+  SyncTextType["Pascal"] = "Pascal";
+})(exports.SyncTextType || (exports.SyncTextType = {}));
+exports.GroupRenderType = void 0;
+(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";
+})(exports.GroupRenderType || (exports.GroupRenderType = {}));
+exports.DisplayDataType = void 0;
+(function (DisplayDataType) {
+  DisplayDataType["Text"] = "Text";
+  DisplayDataType["Html"] = "Html";
+  DisplayDataType["Icon"] = "Icon";
+  DisplayDataType["Custom"] = "Custom";
+})(exports.DisplayDataType || (exports.DisplayDataType = {}));
+exports.ActionStyle = void 0;
+(function (ActionStyle) {
+  ActionStyle["Button"] = "Button";
+  ActionStyle["Secondary"] = "Secondary";
+  ActionStyle["Link"] = "Link";
+  ActionStyle["Group"] = "Group";
+})(exports.ActionStyle || (exports.ActionStyle = {}));
+exports.IconPlacement = void 0;
+(function (IconPlacement) {
+  IconPlacement["BeforeText"] = "BeforeText";
+  IconPlacement["AfterText"] = "AfterText";
+  IconPlacement["ReplaceText"] = "ReplaceText";
+})(exports.IconPlacement || (exports.IconPlacement = {}));
+function visitControlDefinition(x, visitor, defaultValue) {
+  switch (x.type) {
+    case exports.ControlDefinitionType.Action:
+      return visitor.action(x);
+    case exports.ControlDefinitionType.Data:
+      return visitor.data(x);
+    case exports.ControlDefinitionType.Display:
+      return visitor.display(x);
+    case exports.ControlDefinitionType.Group:
+      return visitor.group(x);
+    default:
+      return defaultValue(x);
+  }
+}
+function isGridRenderer(options) {
+  return options.type === exports.GroupRenderType.Grid;
+}
+function isWizardRenderer(options) {
+  return options.type === exports.GroupRenderType.Wizard;
+}
+function isDialogRenderer(options) {
+  return options.type === exports.GroupRenderType.Dialog;
+}
+function isInlineRenderer(options) {
+  return options.type === exports.GroupRenderType.Inline;
+}
+function isSelectChildRenderer(options) {
+  return options.type === exports.GroupRenderType.SelectChild;
+}
+function isTabsRenderer(options) {
+  return options.type === exports.GroupRenderType.Tabs;
+}
+function isFlexRenderer(options) {
+  return options.type === exports.GroupRenderType.Flex;
+}
+function isDisplayOnlyRenderer(options) {
+  return options.type === exports.DataRenderType.DisplayOnly;
+}
+function isTextfieldRenderer(options) {
+  return options.type === exports.DataRenderType.Textfield;
+}
+function isDateTimeRenderer(options) {
+  return options.type === exports.DataRenderType.DateTime;
+}
+function isAutocompleteRenderer(options) {
+  return options.type === exports.DataRenderType.Autocomplete;
+}
+function isAutoCompleteClasses(options) {
+  switch (options == null ? void 0 : options.type) {
+    case exports.DataRenderType.Autocomplete:
+      return true;
+    default:
+      return false;
+  }
+}
+function isDataGroupRenderer(options) {
+  return (options == null ? void 0 : options.type) === exports.DataRenderType.Group;
+}
+function isArrayRenderer(options) {
+  return options.type === exports.DataRenderType.Array;
+}
+function isDataControl(c) {
+  return c.type === exports.ControlDefinitionType.Data;
+}
+function isGroupControl(c) {
+  return c.type === exports.ControlDefinitionType.Group;
+}
+function isActionControl(c) {
+  return c.type === exports.ControlDefinitionType.Action;
+}
+function isDisplayControl(c) {
+  return c.type === exports.ControlDefinitionType.Display;
+}
+function isTextDisplay(d) {
+  return d.type === exports.DisplayDataType.Text;
+}
+function isHtmlDisplay(d) {
+  return d.type === exports.DisplayDataType.Html;
+}
+function isCheckEntryClasses(options) {
+  switch (options == null ? void 0 : options.type) {
+    case exports.DataRenderType.Radio:
+    case exports.DataRenderType.CheckList:
+      return true;
+    default:
+      return false;
+  }
+}
+function traverseParents(current, get, until) {
+  var 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, function (d) {
+    return d.elementIndex == null ? d.schema.field.field : d.elementIndex;
+  }, function (x) {
+    return !x.parent;
+  });
+}
+function getSchemaPath(schemaNode) {
+  return traverseParents(schemaNode, function (d) {
+    return d.field;
+  }, function (x) {
+    return !x.parent;
+  });
+}
+function getSchemaFieldList(schema) {
+  return schema.getChildNodes().map(function (x) {
+    return x.field;
+  });
+}
+function fontAwesomeIcon(icon) {
+  return {
+    library: exports.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;
+}
+
+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 _createForOfIteratorHelperLoose(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (t) return (t = t.call(r)).next.bind(t);
+  if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e && r && "number" == typeof r.length) {
+    t && (r = t);
+    var o = 0;
+    return function () {
+      return o >= r.length ? {
+        done: !0
+      } : {
+        done: !1,
+        value: r[o++]
+      };
+    };
+  }
+  throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+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 _inheritsLoose(t, o) {
+  t.prototype = Object.create(o.prototype), t.prototype.constructor = t, _setPrototypeOf(t, o);
+}
+function _setPrototypeOf(t, e) {
+  return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
+    return t.__proto__ = e, t;
+  }, _setPrototypeOf(t, e);
+}
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+/**
+ * Enum representing the various field types.
+ */
+exports.FieldType = void 0;
+(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";
+})(exports.FieldType || (exports.FieldType = {}));
+/**
+ * Enum representing the various validation message types.
+ */
+exports.ValidationMessageType = void 0;
+(function (ValidationMessageType) {
+  ValidationMessageType["NotEmpty"] = "NotEmpty";
+  ValidationMessageType["MinLength"] = "MinLength";
+  ValidationMessageType["MaxLength"] = "MaxLength";
+  ValidationMessageType["NotAfterDate"] = "NotAfterDate";
+  ValidationMessageType["NotBeforeDate"] = "NotBeforeDate";
+})(exports.ValidationMessageType || (exports.ValidationMessageType = {}));
+function findField(fields, field) {
+  return fields.find(function (x) {
+    return x.field === field;
+  });
+}
+function isScalarField(sf) {
+  return !isCompoundField(sf);
+}
+function isCompoundField(sf) {
+  return sf.type === exports.FieldType.Compound;
+}
+function missingField(field) {
+  return {
+    field: "__missing",
+    type: exports.FieldType.Any,
+    displayName: field
+  };
+}
+exports.SchemaTags = void 0;
+(function (SchemaTags) {
+  SchemaTags["NoControl"] = "_NoControl";
+  SchemaTags["HtmlEditor"] = "_HtmlEditor";
+  SchemaTags["ControlGroup"] = "_ControlGroup:";
+  SchemaTags["ControlRef"] = "_ControlRef:";
+  SchemaTags["IdField"] = "_IdField:";
+})(exports.SchemaTags || (exports.SchemaTags = {}));
+function getTagParam(field, tag) {
+  var _field$tags;
+  return (_field$tags = field.tags) == null || (_field$tags = _field$tags.find(function (x) {
+    return x.startsWith(tag);
+  })) == null ? void 0 : _field$tags.substring(tag.length);
+}
+function makeParamTag(tag, value) {
+  return "" + tag + value;
+}
+
+var SchemaTree = /*#__PURE__*/function () {
+  function SchemaTree() {}
+  var _proto = SchemaTree.prototype;
+  _proto.createChildNode = function createChildNode(parent, field) {
+    return new SchemaNode(parent.id + "/" + field.field, field, this, parent);
+  };
+  _proto.getSchema = function getSchema(schemaId) {
+    var _this$getSchemaTree;
+    return (_this$getSchemaTree = this.getSchemaTree(schemaId)) == null ? void 0 : _this$getSchemaTree.rootNode;
+  };
+  return SchemaTree;
+}();
+var SchemaTreeImpl = /*#__PURE__*/function (_SchemaTree) {
+  function SchemaTreeImpl(rootFields, lookup) {
+    var _this;
+    _this = _SchemaTree.call(this) || this;
+    _this.lookup = void 0;
+    _this.rootNode = void 0;
+    _this.lookup = lookup;
+    _this.rootNode = new SchemaNode("", {
+      type: exports.FieldType.Compound,
+      field: "",
+      children: rootFields
+    }, _this);
+    return _this;
+  }
+  _inheritsLoose(SchemaTreeImpl, _SchemaTree);
+  var _proto2 = SchemaTreeImpl.prototype;
+  _proto2.getSchemaTree = function getSchemaTree(schemaId) {
+    var _this$lookup;
+    return (_this$lookup = this.lookup) == null ? void 0 : _this$lookup.getSchemaTree(schemaId);
+  };
+  return SchemaTreeImpl;
+}(SchemaTree);
+function createSchemaTree(rootFields, lookup) {
+  return new SchemaTreeImpl(rootFields, lookup);
+}
+var SchemaNode = /*#__PURE__*/function () {
+  function SchemaNode(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;
+  }
+  var _proto3 = SchemaNode.prototype;
+  _proto3.getSchema = function getSchema(schemaId) {
+    return this.tree.getSchema(schemaId);
+  };
+  _proto3.getUnresolvedFields = function getUnresolvedFields() {
+    return isCompoundField(this.field) ? this.field.children : [];
+  };
+  _proto3.getResolvedParent = function getResolvedParent(noRecurse) {
+    var _this$parent;
+    var f = this.field;
+    if (!isCompoundField(f)) return undefined;
+    var 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;
+  };
+  _proto3.getResolvedFields = function getResolvedFields() {
+    var _resolvedParent$getUn;
+    var resolvedParent = this.getResolvedParent();
+    return (_resolvedParent$getUn = resolvedParent == null ? void 0 : resolvedParent.getUnresolvedFields()) != null ? _resolvedParent$getUn : [];
+  };
+  _proto3.getChildNodes = function getChildNodes() {
+    var node = this;
+    return node.getResolvedFields().map(function (x) {
+      return node.createChildNode(x);
+    });
+  };
+  _proto3.getChildField = function getChildField(field) {
+    var _this$getResolvedFiel;
+    return (_this$getResolvedFiel = this.getResolvedFields().find(function (x) {
+      return x.field === field;
+    })) != null ? _this$getResolvedFiel : missingField(field);
+  };
+  _proto3.createChildNode = function createChildNode(field) {
+    return this.tree.createChildNode(this, field);
+  };
+  _proto3.getChildNode = function getChildNode(field) {
+    return this.createChildNode(this.getChildField(field));
+  };
+  return SchemaNode;
+}();
+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) {
+  var lookup = {
+    getSchemaTree: getSchemaTree,
+    getSchema: getSchema
+  };
+  return lookup;
+  function getSchema(schemaId) {
+    return getSchemaTree(schemaId).rootNode;
+  }
+  function getSchemaTree(schemaId, additional) {
+    var fields = schemaMap[schemaId];
+    if (fields) {
+      return new SchemaTreeImpl(additional ? [].concat(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) {
+  var i = 0;
+  while (i < fieldPath.length) {
+    var nextField = fieldPath[i];
+    var 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, function (acc, n) {
+    return acc == null ? void 0 : acc[n.field.field];
+  });
+}
+function schemaForFieldPath(fieldPath, schema) {
+  var i = 0;
+  while (i < fieldPath.length) {
+    var nextField = fieldPath[i];
+    var childNode = resolveSchemaNode(schema, nextField);
+    if (!childNode) {
+      childNode = createSchemaNode(missingField(nextField), schema.tree, schema);
+    }
+    schema = childNode;
+    i++;
+  }
+  return schema;
+}
+function getSchemaNodePath(node) {
+  var paths = [];
+  var 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 ".";
+  var parentPath = getSchemaNodePath(parent);
+  var 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) {
+  var i = 0;
+  while (i < parentPath.length && i < childPath.length && parentPath[i] === childPath[i]) {
+    i++;
+  }
+  var upLevels = parentPath.length - i;
+  var downPath = childPath.slice(i).join("/");
+  return "../".repeat(upLevels) + downPath;
+}
+
+function buildSchema(def) {
+  return Object.entries(def).map(function (x) {
+    return x[1](x[0]);
+  });
+}
+function stringField(displayName, options) {
+  return makeScalarField(_extends({
+    type: exports.FieldType.String,
+    displayName: displayName
+  }, options));
+}
+function stringOptionsField(displayName) {
+  return makeScalarField({
+    type: exports.FieldType.String,
+    displayName: displayName,
+    options: [].slice.call(arguments, 1)
+  });
+}
+function withScalarOptions(options, v) {
+  return function (n) {
+    return _extends({}, v(n), options);
+  };
+}
+function makeScalarField(options) {
+  return function (n) {
+    return _extends({}, defaultScalarField(n, n), options);
+  };
+}
+function makeCompoundField(options) {
+  return function (n) {
+    return _extends({}, defaultCompoundField(n, n, false), options);
+  };
+}
+function intField(displayName, options) {
+  return makeScalarField(_extends({
+    type: exports.FieldType.Int,
+    displayName: displayName
+  }, options));
+}
+function doubleField(displayName, options) {
+  return makeScalarField(_extends({
+    type: exports.FieldType.Double,
+    displayName: displayName
+  }, options));
+}
+function dateField(displayName, options) {
+  return makeScalarField(_extends({
+    type: exports.FieldType.Date,
+    displayName: displayName
+  }, options));
+}
+function timeField(displayName, options) {
+  return makeScalarField(_extends({
+    type: exports.FieldType.Time,
+    displayName: displayName
+  }, options));
+}
+function dateTimeField(displayName, options) {
+  return makeScalarField(_extends({
+    type: exports.FieldType.DateTime,
+    displayName: displayName
+  }, options));
+}
+function boolField(displayName, options) {
+  return makeScalarField(_extends({
+    type: exports.FieldType.Bool,
+    displayName: displayName
+  }, options));
+}
+function compoundField(displayName, fields, other) {
+  return function (field) {
+    return _extends({}, defaultCompoundField(field, displayName, false), other, {
+      children: fields
+    });
+  };
+}
+function defaultScalarField(field, displayName) {
+  return {
+    field: field,
+    displayName: displayName,
+    type: exports.FieldType.String
+  };
+}
+function defaultCompoundField(field, displayName, collection) {
+  return {
+    field: field,
+    displayName: displayName,
+    type: exports.FieldType.Compound,
+    collection: collection,
+    children: []
+  };
+}
+function mergeField(field, mergeInto) {
+  var existing = mergeInto.find(function (x) {
+    return x.field === field.field;
+  });
+  if (existing) {
+    return mergeInto.map(function (x) {
+      return x !== existing ? x : _extends({}, x, {
+        onlyForTypes: mergeTypes(x.onlyForTypes, field.onlyForTypes)
+      });
+    });
+  }
+  return [].concat(mergeInto, [field]);
+  function mergeTypes(f, s) {
+    if (!f) return s;
+    if (!s) return f;
+    var extras = s.filter(function (x) {
+      return !f.includes(x);
+    });
+    return extras.length ? [].concat(f, extras) : f;
+  }
+}
+function mergeFields(fields, name, value, newFields) {
+  var withType = fields.map(function (x) {
+    return x.isTypeField ? addFieldOption(x, name, value) : x;
+  });
+  return newFields.map(function (x) {
+    return _extends({}, x, {
+      onlyForTypes: [value]
+    });
+  }).reduce(function (af, x) {
+    return mergeField(x, af);
+  }, withType);
+}
+function addFieldOption(typeField, name, value) {
+  var _typeField$options;
+  var options = (_typeField$options = typeField.options) != null ? _typeField$options : [];
+  if (options.some(function (x) {
+    return x.value === value;
+  })) return typeField;
+  return _extends({}, typeField, {
+    options: [].concat(options, [{
+      name: name,
+      value: value
+    }])
+  });
+}
+function resolveSchemas(schemaMap) {
+  var out = {};
+  function resolveSchemaType(type) {
+    if (type in out) {
+      return out[type];
+    }
+    var resolvedFields = [];
+    out[type] = resolvedFields;
+    schemaMap[type].forEach(function (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;
+}
+
+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) {
+    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;
+  }
+  var _proto = SchemaDataNode.prototype;
+  _proto.getChild = function getChild(childNode) {
+    return this.tree.getChild(this, childNode);
+  };
+  _proto.getChildElement = function getChildElement(elementIndex) {
+    return this.tree.getChildElement(this, elementIndex);
+  };
+  return SchemaDataNode;
+}();
+function getMetaFields(control) {
+  return controls.ensureMetaValue(control, "metaFields", function () {
+    return controls.newControl({});
+  });
+}
+var SchemaDataTreeImpl = /*#__PURE__*/function (_SchemaDataTree) {
+  function SchemaDataTreeImpl(rootSchema, rootControl) {
+    var _this;
+    _this = _SchemaDataTree.call(this) || this;
+    _this.rootNode = void 0;
+    _this.rootNode = new SchemaDataNode("", rootSchema, undefined, rootControl, _this);
+    return _this;
+  }
+  _inheritsLoose(SchemaDataTreeImpl, _SchemaDataTree);
+  var _proto2 = SchemaDataTreeImpl.prototype;
+  _proto2.getChild = function getChild(parent, childNode) {
+    var objControl = parent.control;
+    if (childNode.field.meta) {
+      objControl = getMetaFields(objControl);
+    }
+    var child = objControl.fields[childNode.field.field];
+    return new SchemaDataNode(child.uniqueId.toString(), childNode, undefined, child, this, parent);
+  };
+  _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 SchemaDataTreeImpl;
+}(SchemaDataTree);
+/**
+ * @deprecated Use createSchemaDataNode instead.
+ */
+var 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) {
+  var i = 0;
+  while (i < fieldPath.length) {
+    var _nextNode;
+    var nextField = fieldPath[i];
+    var nextNode = nextField === ".." ? dataNode.parent : nextField === "." ? dataNode : lookupField(nextField);
+    (_nextNode = nextNode) != null ? _nextNode : nextNode = createSchemaDataNode(createSchemaNode(missingField(nextField), dataNode.schema.tree, dataNode.schema), controls.newControl(undefined));
+    dataNode = nextNode;
+    i++;
+  }
+  return dataNode;
+  function lookupField(field) {
+    var childNode = resolveSchemaNode(dataNode.schema, field);
+    if (childNode) {
+      return dataNode.getChild(childNode);
+    }
+    return undefined;
+  }
+}
+function validDataNode(context) {
+  var parent = context.parent;
+  if (!parent) return true;
+  if (parent.schema.field.collection && parent.elementIndex == null) return validDataNode(parent);
+  return controls.ensureMetaValue(context.control, "validForSchema", function () {
+    var c = controls.newControl(true);
+    controls.updateComputedValue(c, function () {
+      if (!validDataNode(parent)) return false;
+      var types = context.schema.field.onlyForTypes;
+      if (types == null || types.length === 0) return true;
+      var typeNode = parent.schema.getChildNodes().find(function (x) {
+        return x.field.isTypeField;
+      });
+      if (typeNode == null) {
+        console.warn("No type field found for", parent.schema);
+        return false;
+      }
+      var typeField = parent.getChild(typeNode).control;
+      return typeField && types.includes(typeField.value);
+    });
+    return c;
+  }).value;
+}
+function hideDisplayOnly(context, schemaInterface, definition) {
+  var _context$control;
+  var displayOptions = getDisplayOnlyOptions(definition);
+  return displayOptions && !displayOptions.emptyText && schemaInterface.isEmptyValue(context.schema.field, (_context$control = context.control) == null ? void 0 : _context$control.value);
+}
+
+var DefaultSchemaInterface = /*#__PURE__*/function () {
+  function DefaultSchemaInterface(boolStrings, parseDateTime) {
+    if (boolStrings === void 0) {
+      boolStrings = ["No", "Yes"];
+    }
+    if (parseDateTime === void 0) {
+      parseDateTime = function parseDateTime(s) {
+        return Date.parse(s);
+      };
+    }
+    this.boolStrings = void 0;
+    this.parseDateTime = void 0;
+    this.boolStrings = boolStrings;
+    this.parseDateTime = parseDateTime;
+  }
+  var _proto = DefaultSchemaInterface.prototype;
+  _proto.parseToMillis = function parseToMillis(field, v) {
+    return this.parseDateTime(v);
+  };
+  _proto.validationMessageText = function validationMessageText(field, messageType, actual, expected) {
+    switch (messageType) {
+      case exports.ValidationMessageType.NotEmpty:
+        return "Please enter a value";
+      case exports.ValidationMessageType.MinLength:
+        return "Length must be at least " + expected;
+      case exports.ValidationMessageType.MaxLength:
+        return "Length must be less than " + expected;
+      case exports.ValidationMessageType.NotBeforeDate:
+        return "Date must not be before " + new Date(expected).toDateString();
+      case exports.ValidationMessageType.NotAfterDate:
+        return "Date must not be after " + new Date(expected).toDateString();
+      default:
+        return "Unknown error";
+    }
+  };
+  _proto.getDataOptions = function getDataOptions(node) {
+    return this.getNodeOptions(node.schema);
+  };
+  _proto.getNodeOptions = function getNodeOptions(node) {
+    return this.getOptions(node.field);
+  };
+  _proto.getOptions = function getOptions(_ref) {
+    var options = _ref.options;
+    return options && options.length > 0 ? options : null;
+  };
+  _proto.getFilterOptions = function getFilterOptions(array, field) {
+    return this.getNodeOptions(field);
+  };
+  _proto.isEmptyValue = function isEmptyValue(f, value) {
+    if (f.collection) return Array.isArray(value) ? value.length === 0 : value == null;
+    switch (f.type) {
+      case exports.FieldType.String:
+      case exports.FieldType.DateTime:
+      case exports.FieldType.Date:
+      case exports.FieldType.Time:
+        return !value;
+      default:
+        return value == null;
+    }
+  };
+  _proto.searchText = function 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 : "";
+  };
+  _proto.textValueForData = function textValueForData(dataNode) {
+    var options = this.getDataOptions(dataNode);
+    return this.textValue(dataNode.schema.field, dataNode.control.value, dataNode.elementIndex != null, options);
+  };
+  _proto.textValue = function textValue(field, value, element, options) {
+    var actualOptions = options != null ? options : this.getOptions(field);
+    var option = actualOptions == null ? void 0 : actualOptions.find(function (x) {
+      return x.value === value;
+    });
+    if (option) return option.name;
+    switch (field.type) {
+      case exports.FieldType.Date:
+        return value ? new Date(value).toLocaleDateString() : undefined;
+      case exports.FieldType.DateTime:
+        return value ? new Date(this.parseToMillis(field, value)).toLocaleString() : undefined;
+      case exports.FieldType.Time:
+        return value ? new Date("1970-01-01T" + value).toLocaleTimeString() : undefined;
+      case exports.FieldType.Bool:
+        return this.boolStrings[value ? 1 : 0];
+      default:
+        return value != null ? value.toString() : undefined;
+    }
+  };
+  _proto.controlLength = function 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);
+  };
+  _proto.valueLength = function valueLength(field, value) {
+    var _ref2;
+    return (_ref2 = value && (value == null ? void 0 : value.length)) != null ? _ref2 : 0;
+  };
+  _proto.compareValue = function compareValue(field, v1, v2) {
+    if (v1 == null) return v2 == null ? 0 : 1;
+    if (v2 == null) return -1;
+    switch (field.type) {
+      case exports.FieldType.Date:
+      case exports.FieldType.DateTime:
+      case exports.FieldType.Time:
+      case exports.FieldType.String:
+        return v1.localeCompare(v2);
+      case exports.FieldType.Bool:
+        return v1 ? v2 ? 0 : 1 : -1;
+      case exports.FieldType.Int:
+      case exports.FieldType.Double:
+        return v1 - v2;
+      default:
+        return 0;
+    }
+  };
+  _proto.compoundFieldSetup = function compoundFieldSetup(f) {
+    var _this = this;
+    return f.getChildNodes().map(function (x) {
+      var field = x.field.field;
+      return [field, _this.makeControlSetup(x)];
+    });
+  };
+  _proto.compoundFieldEquality = function compoundFieldEquality(f) {
+    var _this2 = this;
+    return f.getChildNodes().map(function (x) {
+      var field = x.field.field;
+      return [field, function (a, b) {
+        return _this2.makeEqualityFunc(x)(a[field], b[field]);
+      }];
+    });
+  };
+  _proto.makeEqualityFunc = function makeEqualityFunc(field, element) {
+    if (field.field.collection && !element) {
+      var elemEqual = this.makeEqualityFunc(field, true);
+      return function (a, b) {
+        if (a === b) return true;
+        if (a == null || b == null) return false;
+        if (a.length !== b.length) return false;
+        for (var i = 0; i < a.length; i++) {
+          if (!elemEqual(a[i], b[i])) return false;
+        }
+        return true;
+      };
+    }
+    switch (field.field.type) {
+      case exports.FieldType.Compound:
+        var allChecks = this.compoundFieldEquality(field);
+        return function (a, b) {
+          return a === b || a != null && b != null && allChecks.every(function (x) {
+            return x[1](a, b);
+          });
+        };
+      default:
+        return function (a, b) {
+          return a === b;
+        };
+    }
+  };
+  _proto.makeControlSetup = function makeControlSetup(field, element) {
+    var setup = {
+      equals: this.makeEqualityFunc(field, element)
+    };
+    if (field.field.collection && !element) {
+      setup.elems = this.makeControlSetup(field, true);
+      return setup;
+    }
+    switch (field.field.type) {
+      case exports.FieldType.Compound:
+        setup.fields = Object.fromEntries(this.compoundFieldSetup(field));
+    }
+    return setup;
+  };
+  return DefaultSchemaInterface;
+}();
+var defaultSchemaInterface = new DefaultSchemaInterface();
+
+var FormNode = /*#__PURE__*/function () {
+  function FormNode(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;
+  }
+  var _proto = FormNode.prototype;
+  _proto.visit = function visit(visitFn) {
+    var res = visitFn(this);
+    if (res !== undefined) return res;
+    var children = this.getUnresolvedChildNodes();
+    for (var _iterator = _createForOfIteratorHelperLoose(children), _step; !(_step = _iterator()).done;) {
+      var child = _step.value;
+      var _res = child.visit(visitFn);
+      if (_res !== undefined) return _res;
+    }
+    return undefined;
+  };
+  _proto.getResolvedChildren = function getResolvedChildren() {
+    var _children, _ref;
+    var childRefId = this.definition.childRefId;
+    var parent = childRefId ? this.tree.getByRefId(childRefId) : undefined;
+    return (_children = (_ref = parent != null ? parent : this.definition) == null ? void 0 : _ref.children) != null ? _children : [];
+  };
+  _proto.createChildNode = function createChildNode(childId, childDef) {
+    return new FormNode(this.tree.getChildId(this.id, childId, childDef), childDef, this.tree, this);
+  };
+  _proto.getChildNodes = function getChildNodes() {
+    var _this = this;
+    var resolved = this.getResolvedChildren();
+    return resolved.map(function (x, i) {
+      return _this.createChildNode(i.toString(), x);
+    });
+  };
+  _proto.getUnresolvedChildNodes = function getUnresolvedChildNodes() {
+    var _this$definition$chil,
+      _this$definition$chil2,
+      _this2 = this;
+    return (_this$definition$chil = (_this$definition$chil2 = this.definition.children) == null ? void 0 : _this$definition$chil2.map(function (x, i) {
+      return _this2.createChildNode(i.toString(), x);
+    })) != null ? _this$definition$chil : [];
+  };
+  return FormNode;
+}();
+var FormTree = /*#__PURE__*/function () {
+  function FormTree() {}
+  var _proto2 = FormTree.prototype;
+  _proto2.getChildId = function getChildId(parentId, childId, control) {
+    return parentId + "/" + childId;
+  };
+  return FormTree;
+}();
+function getControlIds(definition) {
+  var _definition$children$, _definition$children;
+  var childEntries = (_definition$children$ = (_definition$children = definition.children) == null ? void 0 : _definition$children.flatMap(getControlIds)) != null ? _definition$children$ : [];
+  return !definition.id ? childEntries : [[definition.id, definition]].concat(childEntries);
+}
+function createControlMap(control) {
+  return Object.fromEntries(getControlIds(control));
+}
+var FormTreeImpl = /*#__PURE__*/function (_FormTree) {
+  function FormTreeImpl(forms, root) {
+    var _this3;
+    _this3 = _FormTree.call(this) || this;
+    _this3.forms = void 0;
+    _this3.controlMap = void 0;
+    _this3.rootNode = void 0;
+    _this3.forms = forms;
+    _this3.rootNode = new FormNode("", root, _this3);
+    _this3.controlMap = createControlMap(root);
+    return _this3;
+  }
+  _inheritsLoose(FormTreeImpl, _FormTree);
+  var _proto3 = FormTreeImpl.prototype;
+  _proto3.getByRefId = function getByRefId(id) {
+    return this.controlMap[id];
+  };
+  _proto3.getForm = function getForm(formId) {
+    return this.forms.getForm(formId);
+  };
+  return FormTreeImpl;
+}(FormTree);
+function legacyFormNode(definition) {
+  return createFormTree([definition]).rootNode.getChildNodes()[0];
+}
+function createFormTree(controls, getForm) {
+  if (getForm === void 0) {
+    getForm = {
+      getForm: function getForm() {
+        return undefined;
+      }
+    };
+  }
+  return new FormTreeImpl(getForm, {
+    type: exports.ControlDefinitionType.Group,
+    children: controls,
+    groupOptions: {
+      type: exports.GroupRenderType.Standard,
+      hideTitle: true
+    }
+  });
+}
+function createFormLookup(formMap) {
+  var lookup = {
+    getForm: getForm
+  };
+  var forms = Object.fromEntries(Object.entries(formMap).map(function (_ref2) {
+    var k = _ref2[0],
+      v = _ref2[1];
+    return [k, createFormTree(v, lookup)];
+  }));
+  return lookup;
+  function getForm(formId) {
+    return forms[formId];
+  }
+}
+function fieldPathForDefinition(c) {
+  var fieldName = isGroupControl(c) ? c.compoundField : isDataControl(c) ? c.field : undefined;
+  return fieldName == null ? void 0 : fieldName.split("/");
+}
+function lookupDataNode(c, parentNode) {
+  var fieldNamePath = fieldPathForDefinition(c);
+  return fieldNamePath ? schemaDataForFieldPath(fieldNamePath, parentNode) : undefined;
+}
+/**
+ * @deprecated use visitFormNodeData instead
+ */
+function visitControlDataArray(controls, context, cb) {
+  if (!controls) return undefined;
+  for (var _iterator2 = _createForOfIteratorHelperLoose(controls), _step2; !(_step2 = _iterator2()).done;) {
+    var c = _step2.value;
+    var 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), function (n, d) {
+    return cb(d, n);
+  });
+}
+function visitFormData(node, dataNode, cb, notSelf) {
+  var def = node.definition;
+  var result = !notSelf && isDataControl(def) ? cb(dataNode, def) : undefined;
+  if (result !== undefined) return result;
+  if (dataNode.elementIndex == null && dataNode.schema.field.collection) {
+    var _l = dataNode.control.elements.length;
+    for (var i = 0; i < _l; i++) {
+      var elemChild = dataNode.getChildElement(i);
+      var elemResult = visitFormData(node, elemChild, cb);
+      if (elemResult !== undefined) return elemResult;
+    }
+    return undefined;
+  }
+  if (dataNode.control.isNull) return undefined;
+  var children = node.getChildNodes();
+  var l = children.length;
+  for (var _i = 0; _i < l; _i++) {
+    var _elemResult = visitFormDataInContext(dataNode, children[_i], cb);
+    if (_elemResult !== undefined) return _elemResult;
+  }
+  return undefined;
+}
+function visitFormDataInContext(parentContext, node, cb) {
+  var 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) {
+  var out = "";
+  jsonPath.forEach(function (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) {
+  var c = controls.newControl(undefined);
+  controls.updateComputedValue(c, compute);
+  controls.addDependent(parent, c);
+  return c.as();
+}
+function createScoped(parent, value, setup) {
+  var c = controls.newControl(value, setup);
+  controls.addDependent(parent, c);
+  return c;
+}
+
+var _defaultEvaluators;
+var dataEval = function dataEval(fvExpr, _ref) {
+  var node = _ref.dataNode,
+    returnResult = _ref.returnResult,
+    scope = _ref.scope;
+  controls.createSyncEffect(function () {
+    var _otherField$control;
+    var otherField = schemaDataForFieldRef(fvExpr.field, node);
+    returnResult((_otherField$control = otherField.control) == null ? void 0 : _otherField$control.value);
+  }, scope);
+};
+var dataMatchEval = function dataMatchEval(matchExpr, _ref2) {
+  var dataNode = _ref2.dataNode,
+    returnResult = _ref2.returnResult,
+    scope = _ref2.scope;
+  controls.createSyncEffect(function () {
+    var otherField = schemaDataForFieldRef(matchExpr.field, dataNode);
+    var fv = otherField == null ? void 0 : otherField.control.value;
+    returnResult(Array.isArray(fv) ? fv.includes(matchExpr.value) : fv === matchExpr.value);
+  }, scope);
+};
+var notEmptyEval = function notEmptyEval(expr, _ref3) {
+  var returnResult = _ref3.returnResult,
+    dataNode = _ref3.dataNode,
+    scope = _ref3.scope,
+    schemaInterface = _ref3.schemaInterface;
+  controls.createSyncEffect(function () {
+    var _otherField$control2;
+    var otherField = schemaDataForFieldRef(expr.field, dataNode);
+    var fv = (_otherField$control2 = otherField.control) == null ? void 0 : _otherField$control2.value;
+    var field = otherField.schema.field;
+    var empty = !!expr.empty;
+    returnResult(field && empty === schemaInterface.isEmptyValue(field, fv));
+  }, scope);
+};
+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);
+        controls.collectChanges(effect.collectUsage, function () {
+          return returnResult(evalResult);
+        });
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  };
+  var scope = _ref4.scope,
+    returnResult = _ref4.returnResult,
+    dataNode = _ref4.dataNode,
+    variables = _ref4.variables;
+  var path = getJsonPath(dataNode);
+  var pathString = jsonPathString(path, function (x) {
+    return "#$i[" + x + "]";
+  });
+  var rootData = getRootDataNode(dataNode).control;
+  var parsedJsonata = createScopedComputed(scope, function () {
+    var jExpr = expr.expression;
+    var fullExpr = pathString ? pathString + ".(" + jExpr + ")" : jExpr;
+    try {
+      return {
+        expr: jsonata__default["default"](fullExpr ? fullExpr : "null"),
+        fullExpr: fullExpr
+      };
+    } catch (e) {
+      console.error(e);
+      return {
+        expr: jsonata__default["default"]("null"),
+        fullExpr: fullExpr
+      };
+    }
+  });
+  controls.createAsyncEffect(runJsonata, scope);
+};
+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);
+
+var _defaultValidators;
+var jsonataValidator = function jsonataValidator(validation, context) {
+  var error = createScopedComputed(context, function () {
+    return undefined;
+  });
+  jsonataEval({
+    type: exports.ExpressionType.Jsonata,
+    expression: validation.expression
+  }, {
+    scope: error,
+    dataNode: context.parentData,
+    returnResult: function returnResult(v) {
+      controls.trackControlChange(context.data.control, controls.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
+  });
+};
+var lengthValidator = function lengthValidator(lv, context) {
+  var schemaInterface = context.schemaInterface;
+  context.addSync(function () {
+    var field = context.data.schema.field;
+    var control = context.data.control;
+    var len = schemaInterface.controlLength(field, control);
+    if (lv.min != null && len < lv.min) {
+      if (field != null && field.collection) {
+        control.setValue(function (v) {
+          return Array.isArray(v) ? v.concat(Array.from({
+            length: lv.min - v.length
+          })) : Array.from({
+            length: lv.min
+          });
+        });
+      } else {
+        return schemaInterface.validationMessageText(field, exports.ValidationMessageType.MinLength, len, lv.min);
+      }
+    } else if (lv.max != null && len > lv.max) {
+      return schemaInterface.validationMessageText(field, exports.ValidationMessageType.MaxLength, len, lv.max);
+    }
+    return undefined;
+  });
+};
+var dateValidator = function dateValidator(dv, context) {
+  var schemaInterface = context.schemaInterface;
+  var field = context.data.schema.field;
+  var comparisonDate;
+  if (dv.fixedDate) {
+    comparisonDate = schemaInterface.parseToMillis(field, dv.fixedDate);
+  } else {
+    var nowDate = new Date();
+    comparisonDate = Date.UTC(nowDate.getFullYear(), nowDate.getMonth(), nowDate.getDate());
+    if (dv.daysFromCurrent) {
+      comparisonDate += dv.daysFromCurrent * 86400000;
+    }
+  }
+  context.addSync(function (v) {
+    if (v) {
+      var selDate = schemaInterface.parseToMillis(field, v);
+      var notAfter = dv.comparison === exports.DateComparison.NotAfter;
+      if (notAfter ? selDate > comparisonDate : selDate < comparisonDate) {
+        return schemaInterface.validationMessageText(field, notAfter ? exports.ValidationMessageType.NotAfterDate : exports.ValidationMessageType.NotBeforeDate, selDate, comparisonDate);
+      }
+    }
+    return null;
+  });
+};
+var defaultValidators = (_defaultValidators = {}, _defaultValidators[exports.ValidatorType.Jsonata] = jsonataValidator, _defaultValidators[exports.ValidatorType.Length] = lengthValidator, _defaultValidators[exports.ValidatorType.Date] = dateValidator, _defaultValidators);
+function createValidators(def, context) {
+  if (isDataControl(def)) {
+    var _def$validators;
+    var schemaInterface = context.schemaInterface;
+    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;
+      });
+    }
+    (_def$validators = def.validators) == null || _def$validators.forEach(function (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) {
+  var validationEnabled = createScopedComputed(controlImpl, function () {
+    return !definition.hidden;
+  });
+  var validatorsScope = controls.createCleanupScope();
+  controls.createEffect(function () {
+    validatorsScope.cleanup();
+    var dn = dataNode.value;
+    if (dn) {
+      var syncValidations = [];
+      createValidators(formNode.definition, {
+        data: dn,
+        parentData: parent,
+        validationEnabled: validationEnabled,
+        schemaInterface: schemaInterface,
+        addSync: function addSync(validate) {
+          syncValidations.push(validate);
+        },
+        addCleanup: function addCleanup(cleanup) {
+          validatorsScope.addCleanup(cleanup);
+        },
+        formContext: controlImpl
+      });
+      controls.createEffect(function () {
+        if (!validationEnabled.value) return undefined;
+        controls.trackControlChange(dn.control, controls.ControlChange.Validate);
+        var value = dn.control.value;
+        var error = null;
+        for (var _i = 0, _syncValidations = syncValidations; _i < _syncValidations.length; _i++) {
+          var syncValidation = _syncValidations[_i];
+          error = syncValidation(value);
+          if (error) break;
+        }
+        return error;
+      }, function (e) {
+        dn.control.setError("default", e);
+      }, validatorsScope);
+    }
+  }, function (c) {}, controlImpl);
+}
+
+function createFormState(schemaInterface, evaluators) {
+  if (evaluators === void 0) {
+    evaluators = defaultEvaluators;
+  }
+  // console.log("createFormState");
+  var controlStates = controls.newControl({});
+  function evalExpression(e, context) {
+    var x = evaluators[e.type];
+    x == null || x(e, context);
+  }
+  return {
+    evalExpression: evalExpression,
+    cleanup: function cleanup() {
+      // console.log("Cleanup form state");
+      controlStates.cleanup();
+    },
+    getControlState: function getControlState(parent, formNode, context) {
+      var _context$stateKey;
+      var stateId = parent.id + "$" + formNode.id + ((_context$stateKey = context.stateKey) != null ? _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
+          });
+          return true;
+        }
+        return false;
+      }
+      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 df = displayOverrides.fields;
+        controls.createScopedEffect(function (c) {
+          var textDisplay = isDisplayControl(def) && isTextDisplay(def.displayData) ? def.displayData : undefined;
+          evalExpr(c, textDisplay == null ? void 0 : textDisplay.text, df.text, textDisplay && firstExpr(formNode, exports.DynamicPropertyType.Display), coerceString);
+        }, displayOverrides);
+        controls.createScopedEffect(function (c) {
+          var htmlDisplay = isDisplayControl(def) && isHtmlDisplay(def.displayData) ? def.displayData : undefined;
+          evalExpr(c, htmlDisplay == null ? void 0 : htmlDisplay.html, df.html, htmlDisplay && firstExpr(formNode, exports.DynamicPropertyType.Display), coerceString);
+        }, displayOverrides);
+        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
+        });
+        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;
+        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.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 || isControlDisabled(definition);
+        });
+        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);
+        setupValidation(controlImpl, definition, dataNode, schemaInterface, parent, formNode);
+        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);
+      });
+    }
+  };
+}
+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 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 controls.ensureMetaValue(c, key, function () {
+    var holder = createScoped(c, undefined, {
+      equals: function equals(a, b) {
+        return a === b;
+      }
+    });
+    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)) {
+        return overrides[p].value;
+      }
+      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);
+    }
+  });
+}
+
+exports.DefaultSchemaInterface = DefaultSchemaInterface;
+exports.FormNode = FormNode;
+exports.FormTree = FormTree;
+exports.SchemaDataNode = SchemaDataNode;
+exports.SchemaDataTree = SchemaDataTree;
+exports.SchemaDataTreeImpl = SchemaDataTreeImpl;
+exports.SchemaNode = SchemaNode;
+exports.SchemaTree = SchemaTree;
+exports.addFieldOption = addFieldOption;
+exports.boolField = boolField;
+exports.buildSchema = buildSchema;
+exports.compoundField = compoundField;
+exports.createControlMap = createControlMap;
+exports.createFormLookup = createFormLookup;
+exports.createFormState = createFormState;
+exports.createFormTree = createFormTree;
+exports.createOverrideProxy = createOverrideProxy;
+exports.createSchemaDataNode = createSchemaDataNode;
+exports.createSchemaLookup = createSchemaLookup;
+exports.createSchemaNode = createSchemaNode;
+exports.createSchemaTree = createSchemaTree;
+exports.createScoped = createScoped;
+exports.createScopedComputed = createScopedComputed;
+exports.dateField = dateField;
+exports.dateTimeField = dateTimeField;
+exports.defaultCompoundField = defaultCompoundField;
+exports.defaultScalarField = defaultScalarField;
+exports.defaultSchemaInterface = defaultSchemaInterface;
+exports.doubleField = doubleField;
+exports.fieldPathForDefinition = fieldPathForDefinition;
+exports.findField = findField;
+exports.fontAwesomeIcon = fontAwesomeIcon;
+exports.getDisplayOnlyOptions = getDisplayOnlyOptions;
+exports.getGroupRendererOptions = getGroupRendererOptions;
+exports.getJsonPath = getJsonPath;
+exports.getMetaFields = getMetaFields;
+exports.getRootDataNode = getRootDataNode;
+exports.getSchemaFieldList = getSchemaFieldList;
+exports.getSchemaNodePath = getSchemaNodePath;
+exports.getSchemaNodePathString = getSchemaNodePathString;
+exports.getSchemaPath = getSchemaPath;
+exports.getTagParam = getTagParam;
+exports.hideDisplayOnly = hideDisplayOnly;
+exports.intField = intField;
+exports.isActionControl = isActionControl;
+exports.isArrayRenderer = isArrayRenderer;
+exports.isAutoCompleteClasses = isAutoCompleteClasses;
+exports.isAutocompleteRenderer = isAutocompleteRenderer;
+exports.isCheckEntryClasses = isCheckEntryClasses;
+exports.isCompoundField = isCompoundField;
+exports.isCompoundNode = isCompoundNode;
+exports.isControlDisabled = isControlDisabled;
+exports.isControlDisplayOnly = isControlDisplayOnly;
+exports.isControlReadonly = isControlReadonly;
+exports.isDataControl = isDataControl;
+exports.isDataGroupRenderer = isDataGroupRenderer;
+exports.isDateTimeRenderer = isDateTimeRenderer;
+exports.isDialogRenderer = isDialogRenderer;
+exports.isDisplayControl = isDisplayControl;
+exports.isDisplayOnlyRenderer = isDisplayOnlyRenderer;
+exports.isFlexRenderer = isFlexRenderer;
+exports.isGridRenderer = isGridRenderer;
+exports.isGroupControl = isGroupControl;
+exports.isHtmlDisplay = isHtmlDisplay;
+exports.isInlineRenderer = isInlineRenderer;
+exports.isScalarField = isScalarField;
+exports.isSelectChildRenderer = isSelectChildRenderer;
+exports.isTabsRenderer = isTabsRenderer;
+exports.isTextDisplay = isTextDisplay;
+exports.isTextfieldRenderer = isTextfieldRenderer;
+exports.isWizardRenderer = isWizardRenderer;
+exports.jsonPathString = jsonPathString;
+exports.legacyFormNode = legacyFormNode;
+exports.lookupDataNode = lookupDataNode;
+exports.makeCompoundField = makeCompoundField;
+exports.makeParamTag = makeParamTag;
+exports.makeScalarField = makeScalarField;
+exports.makeSchemaDataNode = makeSchemaDataNode;
+exports.mergeField = mergeField;
+exports.mergeFields = mergeFields;
+exports.missingField = missingField;
+exports.relativePath = relativePath;
+exports.relativeSegmentPath = relativeSegmentPath;
+exports.resolveSchemaNode = resolveSchemaNode;
+exports.resolveSchemas = resolveSchemas;
+exports.schemaDataForFieldPath = schemaDataForFieldPath;
+exports.schemaDataForFieldRef = schemaDataForFieldRef;
+exports.schemaForFieldPath = schemaForFieldPath;
+exports.schemaForFieldRef = schemaForFieldRef;
+exports.stringField = stringField;
+exports.stringOptionsField = stringOptionsField;
+exports.timeField = timeField;
+exports.traverseData = traverseData;
+exports.traverseParents = traverseParents;
+exports.traverseSchemaPath = traverseSchemaPath;
+exports.validDataNode = validDataNode;
+exports.visitControlData = visitControlData;
+exports.visitControlDataArray = visitControlDataArray;
+exports.visitControlDefinition = visitControlDefinition;
+exports.visitFormData = visitFormData;
+exports.visitFormDataInContext = visitFormDataInContext;
+exports.withScalarOptions = withScalarOptions;
+//# sourceMappingURL=index.cjs.map