@react-typed-forms/schemas 3.0.0-dev.99 → 4.1.0

package/lib/index.js

@@ -1,20 +1,1837 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+var React = require('react');
+var core = require('@react-typed-forms/core');
+var jsonata = require('jsonata');
+var clsx = require('clsx');
+
+function _interopDefaultLegacy (e) { return e && typeof e === 'object' && 'default' in e ? e : { 'default': e }; }
+
+var React__default = /*#__PURE__*/_interopDefaultLegacy(React);
+var jsonata__default = /*#__PURE__*/_interopDefaultLegacy(jsonata);
+var clsx__default = /*#__PURE__*/_interopDefaultLegacy(clsx);
+
+exports.FieldType = void 0;
+(function (FieldType) {
+  FieldType["String"] = "String";
+  FieldType["Bool"] = "Bool";
+  FieldType["Int"] = "Int";
+  FieldType["Date"] = "Date";
+  FieldType["DateTime"] = "DateTime";
+  FieldType["Double"] = "Double";
+  FieldType["EntityRef"] = "EntityRef";
+  FieldType["Compound"] = "Compound";
+  FieldType["AutoId"] = "AutoId";
+  FieldType["Image"] = "Image";
+  FieldType["Any"] = "Any";
+})(exports.FieldType || (exports.FieldType = {}));
+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";
+})(exports.DynamicPropertyType || (exports.DynamicPropertyType = {}));
+exports.ExpressionType = void 0;
+(function (ExpressionType) {
+  ExpressionType["Jsonata"] = "Jsonata";
+  ExpressionType["FieldValue"] = "FieldValue";
+  ExpressionType["UserMatch"] = "UserMatch";
+})(exports.ExpressionType || (exports.ExpressionType = {}));
+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";
+})(exports.ControlAdornmentType || (exports.ControlAdornmentType = {}));
+exports.DataRenderType = void 0;
+(function (DataRenderType) {
+  DataRenderType["Standard"] = "Standard";
+  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";
+})(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["GroupElement"] = "GroupElement";
+})(exports.GroupRenderType || (exports.GroupRenderType = {}));
+exports.DisplayDataType = void 0;
+(function (DisplayDataType) {
+  DisplayDataType["Text"] = "Text";
+  DisplayDataType["Html"] = "Html";
+})(exports.DisplayDataType || (exports.DisplayDataType = {}));
+exports.ValidatorType = void 0;
+(function (ValidatorType) {
+  ValidatorType["Jsonata"] = "Jsonata";
+  ValidatorType["Date"] = "Date";
+})(exports.ValidatorType || (exports.ValidatorType = {}));
+exports.DateComparison = void 0;
+(function (DateComparison) {
+  DateComparison["NotBefore"] = "NotBefore";
+  DateComparison["NotAfter"] = "NotAfter";
+})(exports.DateComparison || (exports.DateComparison = {}));
+function isDataControlDefinition(x) {
+  return x.type === exports.ControlDefinitionType.Data;
+}
+function isGroupControlsDefinition(x) {
+  return x.type === exports.ControlDefinitionType.Group;
+}
+function isDisplayControlsDefinition(x) {
+  return x.type === exports.ControlDefinitionType.Display;
+}
+function isActionControlsDefinition(x) {
+  return x.type === exports.ControlDefinitionType.Action;
+}
+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 _extends() {
+  _extends = Object.assign ? Object.assign.bind() : function (target) {
+    for (var i = 1; i < arguments.length; i++) {
+      var source = arguments[i];
+      for (var key in source) {
+        if (Object.prototype.hasOwnProperty.call(source, key)) {
+          target[key] = source[key];
+        }
+      }
+    }
+    return target;
+  };
+  return _extends.apply(this, arguments);
+}
+function _objectWithoutPropertiesLoose(source, excluded) {
+  if (source == null) return {};
+  var target = {};
+  var sourceKeys = Object.keys(source);
+  var key, i;
+  for (i = 0; i < sourceKeys.length; i++) {
+    key = sourceKeys[i];
+    if (excluded.indexOf(key) >= 0) continue;
+    target[key] = source[key];
+  }
+  return target;
+}
+function _unsupportedIterableToArray(o, minLen) {
+  if (!o) return;
+  if (typeof o === "string") return _arrayLikeToArray(o, minLen);
+  var n = Object.prototype.toString.call(o).slice(8, -1);
+  if (n === "Object" && o.constructor) n = o.constructor.name;
+  if (n === "Map" || n === "Set") return Array.from(o);
+  if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen);
+}
+function _arrayLikeToArray(arr, len) {
+  if (len == null || len > arr.length) len = arr.length;
+  for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i];
+  return arr2;
+}
+function _createForOfIteratorHelperLoose(o, allowArrayLike) {
+  var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"];
+  if (it) return (it = it.call(o)).next.bind(it);
+  if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") {
+    if (it) o = it;
+    var i = 0;
+    return function () {
+      if (i >= o.length) return {
+        done: true
+      };
+      return {
+        done: false,
+        value: o[i++]
+      };
+    };
+  }
+  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 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 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 applyDefaultValues(v, fields) {
+  if (!v) return defaultValueForFields(fields);
+  var applyValue = fields.filter(function (x) {
+    return isCompoundField(x) || !(x.field in v);
+  });
+  if (!applyValue.length) return v;
+  var out = _extends({}, v);
+  applyValue.forEach(function (x) {
+    out[x.field] = x.field in v ? applyDefaultForField(v[x.field], x, fields) : defaultValueForField(x);
+  });
+  return out;
+}
+function applyDefaultForField(v, field, parent, notElement) {
+  if (field.collection && !notElement) {
+    return (v != null ? v : []).map(function (x) {
+      return applyDefaultForField(x, field, parent, true);
+    });
+  }
+  if (isCompoundField(field)) {
+    if (!v && !field.required) return v;
+    return applyDefaultValues(v, field.treeChildren ? parent : field.children);
+  }
+  return defaultValueForField(field);
+}
+function defaultValueForFields(fields) {
+  return Object.fromEntries(fields.map(function (x) {
+    return [x.field, defaultValueForField(x)];
+  }));
+}
+function defaultValueForField(sf, required) {
+  if (sf.defaultValue !== undefined) return sf.defaultValue;
+  var isRequired = !!(required || sf.required);
+  if (isCompoundField(sf)) {
+    if (isRequired) {
+      var childValue = defaultValueForFields(sf.children);
+      return sf.collection ? [childValue] : childValue;
+    }
+    return sf.notNullable ? sf.collection ? [] : {} : undefined;
+  }
+  if (sf.collection) {
+    return isRequired ? [undefined] : [];
+  }
+  return undefined;
+}
+function elementValueForField(sf) {
+  if (isCompoundField(sf)) {
+    return defaultValueForFields(sf.children);
+  }
+  return sf.defaultValue;
+}
+function findScalarField(fields, field) {
+  return findField(fields, field);
+}
+function findCompoundField(fields, field) {
+  return findField(fields, field);
+}
+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 isDataControl(c) {
+  return c.type === exports.ControlDefinitionType.Data;
+}
+function isGroupControl(c) {
+  return c.type === exports.ControlDefinitionType.Group;
+}
+function fieldHasTag(field, tag) {
+  var _field$tags;
+  return Boolean((_field$tags = field.tags) == null ? void 0 : _field$tags.includes(tag));
+}
+function fieldDisplayName(field) {
+  var _field$displayName;
+  return (_field$displayName = field.displayName) != null ? _field$displayName : field.field;
+}
+function hasOptions(o) {
+  var _o$options$length, _o$options;
+  return ((_o$options$length = (_o$options = o.options) == null ? void 0 : _o$options.length) != null ? _o$options$length : 0) > 0;
+}
+function defaultControlForField(sf) {
+  if (isCompoundField(sf)) {
+    return {
+      type: exports.ControlDefinitionType.Group,
+      title: sf.displayName,
+      compoundField: sf.field,
+      groupOptions: {
+        type: exports.GroupRenderType.Grid,
+        hideTitle: false
+      },
+      children: sf.children.map(defaultControlForField)
+    };
+  } else if (isScalarField(sf)) {
+    var _sf$tags;
+    var htmlEditor = (_sf$tags = sf.tags) == null ? void 0 : _sf$tags.includes("_HtmlEditor");
+    return {
+      type: exports.ControlDefinitionType.Data,
+      title: sf.displayName,
+      field: sf.field,
+      required: sf.required,
+      renderOptions: {
+        type: htmlEditor ? exports.DataRenderType.HtmlEditor : exports.DataRenderType.Standard
+      }
+    };
+  }
+  throw "Unknown schema field";
+}
+function findReferencedControl(field, control) {
+  if (isDataControl(control) && field === control.field) return control;
+  if (isGroupControl(control)) {
+    var _control$children;
+    if (control.compoundField) return field === control.compoundField ? control : undefined;
+    return findReferencedControlInArray(field, (_control$children = control.children) != null ? _control$children : []);
+  }
+  return undefined;
+}
+function findReferencedControlInArray(field, controls) {
+  for (var _iterator = _createForOfIteratorHelperLoose(controls), _step; !(_step = _iterator()).done;) {
+    var c = _step.value;
+    var ref = findReferencedControl(field, c);
+    if (ref) return ref;
+  }
+  return undefined;
+}
+function addMissingControls(fields, controls) {
+  var changes = fields.flatMap(function (x) {
+    if (fieldHasTag(x, "_NoControl")) return [];
+    var existing = findReferencedControlInArray(x.field, controls);
+    if (!existing || isCompoundField(x)) return {
+      field: x,
+      existing: existing
+    };
+    return [];
+  });
+  var changedCompounds = controls.map(function (x) {
+    var _cf$children;
+    var ex = changes.find(function (c) {
+      return c.existing === x;
+    });
+    if (!ex) return x;
+    var cf = x;
+    return _extends({}, cf, {
+      children: addMissingControls(ex.field.children, (_cf$children = cf.children) != null ? _cf$children : [])
+    });
+  });
+  return changedCompounds.concat(changes.filter(function (x) {
+    return !x.existing;
+  }).map(function (x) {
+    return defaultControlForField(x.field);
+  }));
+}
+function useUpdatedRef(a) {
+  var r = React.useRef(a);
+  r.current = a;
+  return r;
+}
+function getTypeField(context) {
+  var _context$groupControl;
+  var typeSchemaField = context.fields.find(function (x) {
+    return x.isTypeField;
+  });
+  return typeSchemaField ? (_context$groupControl = context.groupControl.fields) == null ? void 0 : _context$groupControl[typeSchemaField.field] : undefined;
+}
+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;
+}
+function visitControlData(definition, ctx, cb) {
+  return visitControlDefinition(definition, {
+    data: function data(def) {
+      return processData(def, def.field, def.children);
+    },
+    group: function group(d) {
+      return processData(undefined, d.compoundField, d.children);
+    },
+    action: function action() {
+      return undefined;
+    },
+    display: function display() {
+      return undefined;
+    }
+  }, function () {
+    return undefined;
+  });
+  function processData(def, fieldName, children) {
+    var fieldData = fieldName ? findField(ctx.fields, fieldName) : undefined;
+    if (!fieldData) return !fieldName ? visitControlDataArray(children, ctx, cb) : undefined;
+    var control = ctx.groupControl.fields[fieldData.field];
+    var result = def ? cb(def, fieldData, control, false) : undefined;
+    if (result !== undefined) return result;
+    if (fieldData.collection) {
+      for (var _iterator3 = _createForOfIteratorHelperLoose((_control$elements = control.elements) != null ? _control$elements : []), _step3; !(_step3 = _iterator3()).done;) {
+        var _control$elements;
+        var c = _step3.value;
+        var elemResult = def ? cb(def, fieldData, c, true) : undefined;
+        if (elemResult !== undefined) return elemResult;
+        if (isCompoundField(fieldData)) {
+          var cfResult = visitControlDataArray(children, {
+            fields: fieldData.children,
+            groupControl: c
+          }, cb);
+          if (cfResult !== undefined) return cfResult;
+        }
+      }
+    }
+  }
+}
+function cleanDataForSchema(v, fields) {
+  if (!v) return v;
+  var typeField = fields.find(function (x) {
+    return x.isTypeField;
+  });
+  if (!typeField) return v;
+  var typeValue = v[typeField.field];
+  var cleanableFields = fields.filter(function (x) {
+    var _x$onlyForTypes$lengt, _x$onlyForTypes;
+    return isCompoundField(x) || ((_x$onlyForTypes$lengt = (_x$onlyForTypes = x.onlyForTypes) == null ? void 0 : _x$onlyForTypes.length) != null ? _x$onlyForTypes$lengt : 0) > 0;
+  });
+  if (!cleanableFields.length) return v;
+  var out = _extends({}, v);
+  cleanableFields.forEach(function (x) {
+    var _x$onlyForTypes2;
+    var childValue = v[x.field];
+    if (((_x$onlyForTypes2 = x.onlyForTypes) == null ? void 0 : _x$onlyForTypes2.includes(typeValue)) === false || !x.notNullable && canBeNull()) {
+      delete out[x.field];
+      return;
+    }
+    if (isCompoundField(x)) {
+      var childFields = x.treeChildren ? fields : x.children;
+      if (x.collection) {
+        if (Array.isArray(childValue)) {
+          out[x.field] = childValue.map(function (cv) {
+            return cleanDataForSchema(cv, childFields);
+          });
+        }
+      } else {
+        out[x.field] = cleanDataForSchema(childValue, childFields);
+      }
+    }
+    function canBeNull() {
+      return x.collection && Array.isArray(childValue) && !childValue.length
+      //|| (x.type === FieldType.Bool && childValue === false)
+      ;
+    }
+  });
+
+  return out;
+}
+
+function dataControl(field, title, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Data,
+    field: field,
+    title: title
+  }, options);
+}
+function textDisplayControl(text, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Display,
+    displayData: {
+      type: exports.DisplayDataType.Text,
+      text: text
+    }
+  }, options);
+}
+function htmlDisplayControl(html, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Display,
+    displayData: {
+      type: exports.DisplayDataType.Html,
+      html: html
+    }
+  }, options);
+}
+function dynamicDefaultValue(expr) {
+  return {
+    type: exports.DynamicPropertyType.DefaultValue,
+    expr: expr
+  };
+}
+function visibility(expr) {
+  return {
+    type: exports.DynamicPropertyType.Visible,
+    expr: expr
+  };
+}
+function fieldEqExpr(field, value) {
+  return {
+    type: exports.ExpressionType.FieldValue,
+    field: field,
+    value: value
+  };
+}
+function jsonataExpr(expression) {
+  return {
+    type: exports.ExpressionType.Jsonata,
+    expression: expression
+  };
+}
+function groupedControl(children, title, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Group,
+    children: children,
+    title: title,
+    groupOptions: {
+      type: "Standard",
+      hideTitle: !title
+    }
+  }, options);
+}
+function compoundControl(field, title, children, options) {
+  return _extends({
+    type: exports.ControlDefinitionType.Data,
+    field: field,
+    children: children,
+    title: title,
+    renderOptions: {
+      type: "Standard"
+    }
+  }, options);
+}
+function createAction(actionId, onClick, actionText) {
+  return {
+    actionId: actionId,
+    onClick: onClick,
+    actionText: actionText != null ? actionText : actionId
+  };
+}
+var emptyGroupDefinition = {
+  type: exports.ControlDefinitionType.Group,
+  children: [],
+  groupOptions: {
+    type: exports.GroupRenderType.Standard,
+    hideTitle: true
+  }
+};
+function useControlDefinitionForSchema(sf, definition) {
+  if (definition === void 0) {
+    definition = emptyGroupDefinition;
+  }
+  return React.useMemo(function () {
+    var _definition$children;
+    return _extends({}, definition, {
+      children: addMissingControls(sf, (_definition$children = definition.children) != null ? _definition$children : [])
+    });
+  }, [sf, definition]);
+}
+
+function useEvalVisibilityHook(definition, schemaField) {
+  var dynamicVisibility = useEvalDynamicHook(definition, exports.DynamicPropertyType.Visible);
+  var r = useUpdatedRef(schemaField);
+  return React.useCallback(function (ctx) {
+    var _dynamicVisibility;
+    var schemaField = r.current;
+    return (_dynamicVisibility = dynamicVisibility == null ? void 0 : dynamicVisibility(ctx)) != null ? _dynamicVisibility : core.useComputed(function () {
+      return matchesType(ctx, schemaField == null ? void 0 : schemaField.onlyForTypes);
+    });
+  }, [dynamicVisibility, r]);
+}
+function useEvalDefaultValueHook(definition, schemaField) {
+  var dynamicValue = useEvalDynamicHook(definition, exports.DynamicPropertyType.DefaultValue);
+  var r = useUpdatedRef({
+    definition: definition,
+    schemaField: schemaField
+  });
+  return React.useCallback(function (ctx) {
+    var _dynamicValue;
+    var _r$current = r.current,
+      definition = _r$current.definition,
+      schemaField = _r$current.schemaField;
+    return (_dynamicValue = dynamicValue == null ? void 0 : dynamicValue(ctx)) != null ? _dynamicValue : core.useComputed(calcDefault);
+    function calcDefault() {
+      var _ref = isDataControlDefinition(definition) ? [definition.required, definition.defaultValue] : [false, undefined],
+        required = _ref[0],
+        dcv = _ref[1];
+      return dcv != null ? dcv : schemaField ? defaultValueForField(schemaField, required) : undefined;
+    }
+  }, [dynamicValue, r]);
+}
+function useFieldValueExpression(fvExpr, fields, data) {
+  var refField = findField(fields, fvExpr.field);
+  var otherField = refField ? data.fields[refField.field] : undefined;
+  return core.useComputed(function () {
+    var fv = otherField == null ? void 0 : otherField.value;
+    return Array.isArray(fv) ? fv.includes(fvExpr.value) : fv === fvExpr.value;
+  });
+}
+function useEvalExpressionHook(expr) {
+  var r = useUpdatedRef(expr);
+  var cb = React.useCallback(function (_ref2) {
+    var groupControl = _ref2.groupControl,
+      fields = _ref2.fields;
+    var expr = r.current;
+    switch (expr.type) {
+      case exports.ExpressionType.Jsonata:
+        return useJsonataExpression(expr.expression, groupControl);
+      case exports.ExpressionType.FieldValue:
+        return useFieldValueExpression(expr, fields, groupControl);
+      default:
+        return core.useControl(undefined);
+    }
+  }, [expr == null ? void 0 : expr.type, r]);
+  return expr ? cb : undefined;
+}
+function useEvalDynamicHook(definition, type) {
+  var _definition$dynamic;
+  var expression = (_definition$dynamic = definition.dynamic) == null ? void 0 : _definition$dynamic.find(function (x) {
+    return x.type === type;
+  });
+  return useEvalExpressionHook(expression == null ? void 0 : expression.expr);
+}
+function matchesType(context, types) {
+  if (types == null || types.length === 0) return true;
+  var typeField = getTypeField(context);
+  return typeField && types.includes(typeField.value);
+}
+function useJsonataExpression(jExpr, data) {
+  var compiledExpr = React.useMemo(function () {
+    return jsonata__default["default"](jExpr);
+  }, [jExpr]);
+  var control = core.useControl();
+  core.useControlEffect(function () {
+    return data.value;
+  }, function (v) {
+    try {
+      return Promise.resolve(compiledExpr.evaluate(v)).then(function (_compiledExpr$evaluat) {
+        control.value = _compiledExpr$evaluat;
+      });
+    } catch (e) {
+      return Promise.reject(e);
+    }
+  }, true);
+  return control;
+}
+
+function useValidationHook(definition) {
+  var _definition$validator, _definition$validator2;
+  var validatorTypes = isDataControlDefinition(definition) ? (_definition$validator = (_definition$validator2 = definition.validators) == null ? void 0 : _definition$validator2.map(function (x) {
+    return x.type;
+  })) != null ? _definition$validator : [] : null;
+  var r = useUpdatedRef(definition);
+  return React.useCallback(function (control, hidden, groupContext) {
+    var _dd$validators;
+    if (!validatorTypes) return;
+    var dd = r.current;
+    core.useValueChangeEffect(control, function () {
+      return control.setError("default", "");
+    });
+    core.useValidator(control, function (v) {
+      return !hidden && dd.required && (v == null || v === "" || Array.isArray(v) && v.length === 0) ? "Please enter a value" : null;
+    }, "required");
+    ((_dd$validators = dd.validators) != null ? _dd$validators : []).forEach(function (x, i) {
+      switch (x.type) {
+        case exports.ValidatorType.Jsonata:
+          return useJsonataValidator(control, groupContext, x, hidden, i);
+        case exports.ValidatorType.Date:
+          return useDateValidator(control, x, i);
+      }
+    });
+  }, validatorTypes ? validatorTypes : [null]);
+}
+function useJsonataValidator(control, context, expr, hidden, i) {
+  var errorMsg = useJsonataExpression(expr.expression, context.groupControl);
+  core.useControlEffect(function () {
+    return [hidden, errorMsg.value];
+  }, function (_ref) {
+    var hidden = _ref[0],
+      msg = _ref[1];
+    return control.setError("jsonata" + i, !hidden ? msg : null);
+  }, true);
+}
+function useDateValidator(control, dv, i) {
+  var comparisonDate;
+  if (dv.fixedDate) {
+    comparisonDate = Date.parse(dv.fixedDate);
+  } else {
+    var nowDate = new Date();
+    comparisonDate = Date.UTC(nowDate.getFullYear(), nowDate.getMonth(), nowDate.getDate());
+    if (dv.daysFromCurrent) {
+      comparisonDate += dv.daysFromCurrent * 86400000;
+    }
+  }
+  core.useValidator(control, function (v) {
+    if (v) {
+      var selDate = Date.parse(v);
+      var notAfter = dv.comparison === exports.DateComparison.NotAfter;
+      if (notAfter ? selDate > comparisonDate : selDate < comparisonDate) {
+        return "Date must not be " + (notAfter ? "after" : "before") + " " + new Date(comparisonDate).toDateString();
+      }
+    }
+    return null;
+  }, "date" + i);
+}
+
+var AppendAdornmentPriority = 0;
+var WrapAdornmentPriority = 1000;
+exports.LabelType = void 0;
+(function (LabelType) {
+  LabelType[LabelType["Control"] = 0] = "Control";
+  LabelType[LabelType["Group"] = 1] = "Group";
+})(exports.LabelType || (exports.LabelType = {}));
+function useControlRenderer(definition, fields, renderer, options) {
+  var _options$useDataHook;
+  if (options === void 0) {
+    options = {};
+  }
+  var dataProps = (_options$useDataHook = options.useDataHook == null ? void 0 : options.useDataHook(definition)) != null ? _options$useDataHook : defaultDataProps;
+  var schemaField = lookupSchemaField(definition, fields);
+  var useDefaultValue = useEvalDefaultValueHook(definition, schemaField);
+  var useIsVisible = useEvalVisibilityHook(definition, schemaField);
+  var useValidation = useValidationHook(definition);
+  var r = useUpdatedRef({
+    options: options,
+    definition: definition,
+    fields: fields,
+    schemaField: schemaField
+  });
+  var Component = React.useCallback(function (_ref) {
+    var parentControl = _ref.control;
+    var stopTracking = core.useComponentTracking();
+    try {
+      var _c$children$map, _c$children, _definition$adornment, _definition$adornment2;
+      var _r$current = r.current,
+        c = _r$current.definition,
+        _options = _r$current.options,
+        _fields = _r$current.fields,
+        _schemaField = _r$current.schemaField;
+      var groupContext = {
+        groupControl: parentControl,
+        fields: _fields
+      };
+      var visibleControl = useIsVisible(groupContext);
+      var visible = visibleControl.current.value;
+      var visibility = core.useControl(function () {
+        return visible != null ? {
+          visible: visible,
+          showing: visible
+        } : undefined;
+      });
+      core.useControlEffect(function () {
+        return visibleControl.value;
+      }, function (visible) {
+        if (visible != null) visibility.setValue(function (ex) {
+          return {
+            visible: visible,
+            showing: ex ? ex.showing : visible
+          };
+        });
+      });
+      var defaultValueControl = useDefaultValue(groupContext);
+      var _getControlData = getControlData(_schemaField, groupContext),
+        control = _getControlData[0],
+        childContext = _getControlData[1];
+      core.useControlEffect(function () {
+        return [visibility.value, defaultValueControl.value, control, parentControl.isNull];
+      }, function (_ref2) {
+        var vc = _ref2[0],
+          dv = _ref2[1],
+          cd = _ref2[2],
+          pn = _ref2[3];
+        if (pn) {
+          parentControl.value = {};
+        }
+        if (vc && cd && vc.visible === vc.showing) {
+          if (!vc.visible) {
+            if (_options.clearHidden) cd.value = undefined;
+          } else if (cd.value == null) {
+            cd.value = dv;
+          }
+        }
+      }, true);
+      var hidden = core.useComputed(function () {
+        var _visibility$fields;
+        return _options.hidden || !((_visibility$fields = visibility.fields) != null && _visibility$fields.showing.value);
+      }).value;
+      useValidation(control, hidden, groupContext);
+      var myOptions = _options.hidden !== hidden ? _extends({}, _options, {
+        hidden: hidden
+      }) : _options;
+      var childRenderers = (_c$children$map = (_c$children = c.children) == null ? void 0 : _c$children.map(function (cd) {
+        return useControlRenderer(cd, childContext.fields, renderer, myOptions);
+      })) != null ? _c$children$map : [];
+      if (parentControl.isNull) return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null);
+      var adornments = (_definition$adornment = (_definition$adornment2 = definition.adornments) == null ? void 0 : _definition$adornment2.map(function (x) {
+        return renderer.renderAdornment({
+          adornment: x
+        });
+      })) != null ? _definition$adornment : [];
+      var labelAndChildren = renderControlLayout(c, renderer, childRenderers.length, function (k, i, props) {
+        var RenderChild = childRenderers[i];
+        return /*#__PURE__*/React__default["default"].createElement(RenderChild, _extends({
+          key: k
+        }, props));
+      }, dataProps, myOptions, groupContext, control, _schemaField);
+      return renderer.renderVisibility(visibility, function () {
+        return renderer.renderLayout(_extends({}, labelAndChildren, {
+          adornments: adornments
+        }));
+      });
+    } finally {
+      stopTracking();
+    }
+  }, [r, dataProps, useIsVisible, useDefaultValue, useValidation, renderer]);
+  Component.displayName = "RenderControl";
+  return Component;
+}
+function lookupSchemaField(c, fields) {
+  var fieldName = isGroupControlsDefinition(c) ? c.compoundField : isDataControlDefinition(c) ? c.field : undefined;
+  return fieldName ? findField(fields, fieldName) : undefined;
+}
+function getControlData(schemaField, parentContext) {
+  var _parentContext$groupC, _parentContext$groupC2;
+  var childControl = schemaField ? (_parentContext$groupC = (_parentContext$groupC2 = parentContext.groupControl.fields) == null ? void 0 : _parentContext$groupC2[schemaField.field]) != null ? _parentContext$groupC : core.newControl({}) : undefined;
+  return [childControl, schemaField && isCompoundField(schemaField) ? {
+    groupControl: childControl,
+    fields: schemaField.children
+  } : parentContext];
+}
+function renderArray(renderer, noun, field, required, arrayControl, _renderChild) {
+  var _arrayControl$element;
+  var elems = (_arrayControl$element = arrayControl.elements) != null ? _arrayControl$element : [];
+  return renderer.renderArray({
+    arrayControl: arrayControl,
+    childCount: elems.length,
+    required: required,
+    addAction: {
+      actionId: "add",
+      actionText: "Add " + noun,
+      onClick: function onClick() {
+        return core.addElement(arrayControl, elementValueForField(field));
+      }
+    },
+    childKey: function childKey(i) {
+      return elems[i].uniqueId;
+    },
+    removeAction: function removeAction(i) {
+      return {
+        actionId: "",
+        actionText: "Remove",
+        onClick: function onClick() {
+          return core.removeElement(arrayControl, i);
+        }
+      };
+    },
+    renderChild: function renderChild(i) {
+      return _renderChild(i, elems[i]);
+    }
+  });
+}
+function groupProps(renderOptions, childCount, _renderChild2, control) {
+  if (renderOptions === void 0) {
+    renderOptions = {
+      type: "Standard"
+    };
+  }
+  return {
+    childCount: childCount,
+    renderChild: function renderChild(i) {
+      return _renderChild2(i, i, {
+        control: control
+      });
+    },
+    renderOptions: renderOptions
+  };
+}
+var defaultDataProps = function defaultDataProps(definition, field, groupContext, control, options) {
+  var _field$options$length, _field$options, _definition$renderOpt;
+  return {
+    control: control,
+    field: field,
+    id: "c" + control.uniqueId,
+    options: ((_field$options$length = (_field$options = field.options) == null ? void 0 : _field$options.length) != null ? _field$options$length : 0) === 0 ? null : field.options,
+    readonly: options.readonly || !!definition.readonly,
+    renderOptions: (_definition$renderOpt = definition.renderOptions) != null ? _definition$renderOpt : {
+      type: "Standard"
+    },
+    required: !!definition.required,
+    hidden: !!options.hidden
+  };
+};
+function renderControlLayout(c, renderer, childCount, childRenderer, dataProps, dataOptions, groupContext, childControl, schemaField) {
+  if (isDataControlDefinition(c)) {
+    return renderData(c);
+  }
+  if (isGroupControlsDefinition(c)) {
+    var _c$groupOptions2;
+    if (c.compoundField) {
+      var _c$groupOptions;
+      return renderData(dataControl(c.compoundField, c.title, {
+        children: c.children,
+        hideTitle: (_c$groupOptions = c.groupOptions) == null ? void 0 : _c$groupOptions.hideTitle
+      }));
+    }
+    return {
+      children: renderer.renderGroup(groupProps(c.groupOptions, childCount, childRenderer, groupContext.groupControl)),
+      label: {
+        label: c.title,
+        type: exports.LabelType.Group,
+        hide: (_c$groupOptions2 = c.groupOptions) == null ? void 0 : _c$groupOptions2.hideTitle
+      }
+    };
+  }
+  if (isActionControlsDefinition(c)) {
+    var _c$title;
+    return {
+      children: renderer.renderAction({
+        actionText: (_c$title = c.title) != null ? _c$title : c.actionId,
+        actionId: c.actionId,
+        onClick: function onClick() {}
+      })
+    };
+  }
+  if (isDisplayControlsDefinition(c)) {
+    var _c$displayData;
+    return {
+      children: renderer.renderDisplay({
+        data: (_c$displayData = c.displayData) != null ? _c$displayData : {}
+      })
+    };
+  }
+  return {};
+  function renderData(c) {
+    if (!schemaField) return {
+      children: "No schema field for: " + c.field
+    };
+    if (isCompoundField(schemaField)) {
+      var label = {
+        hide: c.hideTitle,
+        label: controlTitle(c.title, schemaField),
+        type: schemaField.collection ? exports.LabelType.Control : exports.LabelType.Group
+      };
+      if (schemaField.collection) {
+        return {
+          label: label,
+          children: renderArray(renderer, controlTitle(c.title, schemaField), schemaField, !!c.required, childControl, compoundRenderer),
+          errorControl: childControl
+        };
+      }
+      return {
+        children: renderer.renderGroup(groupProps({
+          type: "Standard"
+        }, childCount, childRenderer, childControl)),
+        label: label,
+        errorControl: childControl
+      };
+    }
+    var props = dataProps(c, schemaField, groupContext, childControl, dataOptions);
+    var labelText = !c.hideTitle ? controlTitle(c.title, schemaField) : undefined;
+    return {
+      processLayout: renderer.renderData(props, schemaField.collection ? function () {
+        return renderArray(renderer, controlTitle(c.title, schemaField), schemaField, !!c.required, childControl, scalarRenderer(props));
+      } : undefined),
+      label: {
+        type: exports.LabelType.Control,
+        label: labelText,
+        forId: props.id,
+        required: c.required,
+        hide: c.hideTitle
+      },
+      errorControl: childControl
+    };
+  }
+  function compoundRenderer(i, control) {
+    return /*#__PURE__*/React__default["default"].createElement(React.Fragment, {
+      key: control.uniqueId
+    }, renderer.renderGroup({
+      renderOptions: {
+        type: "Standard",
+        hideTitle: true
+      },
+      childCount: childCount,
+      renderChild: function renderChild(ci) {
+        return childRenderer(ci, ci, {
+          control: control
+        });
+      }
+    }));
+  }
+  function scalarRenderer(dataProps) {
+    return function (i, control) {
+      return /*#__PURE__*/React__default["default"].createElement(React.Fragment, {
+        key: control.uniqueId
+      }, renderer.renderData(_extends({}, dataProps, {
+        control: control
+      }), undefined)({}).children);
+    };
+  }
+}
+function appendMarkup(k, markup) {
+  return function (layout) {
+    return layout[k] = /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, layout[k], markup);
+  };
+}
+function wrapMarkup(k, wrap) {
+  return function (layout) {
+    return layout[k] = wrap(layout[k]);
+  };
+}
+function layoutKeyForPlacement(pos) {
+  switch (pos) {
+    case exports.AdornmentPlacement.ControlEnd:
+      return "controlEnd";
+    case exports.AdornmentPlacement.ControlStart:
+      return "controlStart";
+    case exports.AdornmentPlacement.LabelStart:
+      return "labelStart";
+    case exports.AdornmentPlacement.LabelEnd:
+      return "labelEnd";
+  }
+}
+function appendMarkupAt(pos, markup) {
+  return appendMarkup(layoutKeyForPlacement(pos), markup);
+}
+function wrapMarkupAt(pos, wrap) {
+  return wrapMarkup(layoutKeyForPlacement(pos), wrap);
+}
+function renderLayoutParts(props, renderer) {
+  var _props$processLayout, _processed$adornments;
+  var processed = (_props$processLayout = props.processLayout == null ? void 0 : props.processLayout(props)) != null ? _props$processLayout : props;
+  var layout = {
+    children: processed.children
+  };
+  ((_processed$adornments = processed.adornments) != null ? _processed$adornments : []).sort(function (a, b) {
+    return a.priority - b.priority;
+  }).forEach(function (x) {
+    return x.apply(layout);
+  });
+  var l = processed.label;
+  layout.label = l && !l.hide ? renderer.renderLabel(l, layout.labelStart, layout.labelEnd) : undefined;
+  return layout;
+}
+function controlTitle(title, field) {
+  return title ? title : fieldDisplayName(field);
+}
+
+var _excluded = ["control", "convert"],
+  _excluded2 = ["errorText", "value", "onChange"],
+  _excluded3 = ["state", "options", "className", "convert", "required", "emptyText", "requiredText"];
+function createFormRenderer(customRenderers, defaultRenderers) {
+  var _customRenderers$find;
+  if (customRenderers === void 0) {
+    customRenderers = [];
+  }
+  if (defaultRenderers === void 0) {
+    defaultRenderers = createClassStyledRenderers();
+  }
+  var dataRegistrations = customRenderers.filter(isDataRegistration);
+  var groupRegistrations = customRenderers.filter(isGroupRegistration);
+  var adornmentRegistrations = customRenderers.filter(isAdornmentRegistration);
+  var displayRegistrations = customRenderers.filter(isDisplayRegistration);
+  var labelRenderers = customRenderers.filter(isLabelRegistration);
+  var arrayRenderers = customRenderers.filter(isArrayRegistration);
+  var actionRenderers = customRenderers.filter(isActionRegistration);
+  var layoutRenderers = customRenderers.filter(isLayoutRegistration);
+  var visibilityRenderer = (_customRenderers$find = customRenderers.find(isVisibilityRegistration)) != null ? _customRenderers$find : defaultRenderers.visibility;
+  var formRenderers = {
+    renderAction: renderAction,
+    renderData: renderData,
+    renderGroup: renderGroup,
+    renderDisplay: renderDisplay,
+    renderLabel: renderLabel,
+    renderArray: renderArray,
+    renderAdornment: renderAdornment,
+    renderLayout: renderLayout,
+    renderVisibility: visibilityRenderer.render
+  };
+  function renderLayout(props) {
+    var _layoutRenderers$find;
+    var renderer = (_layoutRenderers$find = layoutRenderers.find(function (x) {
+      return !x.match || x.match(props);
+    })) != null ? _layoutRenderers$find : defaultRenderers.renderLayout;
+    return renderer.render(props, formRenderers);
+  }
+  function renderAdornment(props) {
+    var _adornmentRegistratio;
+    var renderer = (_adornmentRegistratio = adornmentRegistrations.find(function (x) {
+      return isOneOf(x.adornmentType, props.adornment.type);
+    })) != null ? _adornmentRegistratio : defaultRenderers.adornment;
+    return renderer.render(props);
+  }
+  function renderArray(props) {
+    var _arrayRenderers$;
+    return ((_arrayRenderers$ = arrayRenderers[0]) != null ? _arrayRenderers$ : defaultRenderers.array).render(props, formRenderers);
+  }
+  function renderLabel(props, labelStart, labelEnd) {
+    var _labelRenderers$find;
+    var renderer = (_labelRenderers$find = labelRenderers.find(function (x) {
+      return isOneOf(x.labelType, props.type);
+    })) != null ? _labelRenderers$find : defaultRenderers.label;
+    return renderer.render(props, labelStart, labelEnd, formRenderers);
+  }
+  function renderData(props, asArray) {
+    var _dataRegistrations$fi;
+    var renderType = props.renderOptions.type,
+      field = props.field;
+    var options = hasOptions(props);
+    var renderer = (_dataRegistrations$fi = dataRegistrations.find(function (x) {
+      var _x$collection, _field$collection, _x$options;
+      return ((_x$collection = x.collection) != null ? _x$collection : false) === ((_field$collection = field.collection) != null ? _field$collection : false) && ((_x$options = x.options) != null ? _x$options : false) === options && isOneOf(x.schemaType, field.type) && isOneOf(x.renderType, renderType) && (!x.match || x.match(props));
+    })) != null ? _dataRegistrations$fi : defaultRenderers.data;
+    var result = renderer.render(props, asArray, formRenderers);
+    if (typeof result === "function") return result;
+    return function (l) {
+      return _extends({}, l, {
+        children: result
+      });
+    };
+  }
+  function renderGroup(props) {
+    var _groupRegistrations$f;
+    var renderType = props.renderOptions.type;
+    var renderer = (_groupRegistrations$f = groupRegistrations.find(function (x) {
+      return isOneOf(x.renderType, renderType);
+    })) != null ? _groupRegistrations$f : defaultRenderers.group;
+    return renderer.render(props, formRenderers);
+  }
+  function renderAction(props) {
+    var _actionRenderers$find;
+    var renderer = (_actionRenderers$find = actionRenderers.find(function (x) {
+      return isOneOf(x.actionType, props.actionId);
+    })) != null ? _actionRenderers$find : defaultRenderers.action;
+    return renderer.render(props, formRenderers);
+  }
+  function renderDisplay(props) {
+    var _displayRegistrations;
+    var renderType = props.data.type;
+    var renderer = (_displayRegistrations = displayRegistrations.find(function (x) {
+      return isOneOf(x.renderType, renderType);
+    })) != null ? _displayRegistrations : defaultRenderers.display;
+    return renderer.render(props, formRenderers);
+  }
+  return formRenderers;
+}
+function createDefaultActionRenderer(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  function render(_ref) {
+    var onClick = _ref.onClick,
+      actionText = _ref.actionText;
+    return /*#__PURE__*/React__default["default"].createElement("button", {
+      className: options.className,
+      onClick: onClick
+    }, actionText);
+  }
+  return {
+    render: render,
+    type: "action"
+  };
+}
+function createDefaultLabelRenderer(options) {
+  if (options === void 0) {
+    options = {
+      requiredElement: /*#__PURE__*/React__default["default"].createElement("span", null, " *")
+    };
+  }
+  var _options = options,
+    className = _options.className,
+    groupLabelClass = _options.groupLabelClass,
+    requiredElement = _options.requiredElement;
+  return {
+    render: function render(props, labelStart, labelEnd) {
+      return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, labelStart, /*#__PURE__*/React__default["default"].createElement("label", {
+        htmlFor: props.forId,
+        className: clsx__default["default"](className, props.type === exports.LabelType.Group && groupLabelClass)
+      }, props.label, props.required && requiredElement), labelEnd);
+    },
+    type: "label"
+  };
+}
+function createDefaultArrayRenderer(options) {
+  var _ref2 = options != null ? options : {},
+    className = _ref2.className,
+    removableClass = _ref2.removableClass,
+    childClass = _ref2.childClass,
+    removableChildClass = _ref2.removableChildClass,
+    removeActionClass = _ref2.removeActionClass,
+    addActionClass = _ref2.addActionClass;
+  function render(_ref3, _ref4) {
+    var childCount = _ref3.childCount,
+      renderChild = _ref3.renderChild,
+      addAction = _ref3.addAction,
+      removeAction = _ref3.removeAction,
+      childKey = _ref3.childKey,
+      required = _ref3.required;
+    var renderAction = _ref4.renderAction;
+    var showRemove = !required || childCount > 1;
+    return /*#__PURE__*/React__default["default"].createElement("div", null, /*#__PURE__*/React__default["default"].createElement("div", {
+      className: clsx__default["default"](className, removeAction && removableClass)
+    }, Array.from({
+      length: childCount
+    }, function (_, x) {
+      return removeAction ? /*#__PURE__*/React__default["default"].createElement(React.Fragment, {
+        key: childKey(x)
+      }, /*#__PURE__*/React__default["default"].createElement("div", {
+        className: clsx__default["default"](childClass, removableChildClass)
+      }, renderChild(x)), /*#__PURE__*/React__default["default"].createElement("div", {
+        className: removeActionClass
+      }, showRemove && renderAction(removeAction(x)))) : /*#__PURE__*/React__default["default"].createElement("div", {
+        key: childKey(x),
+        className: childClass
+      }, renderChild(x));
+    })), addAction && /*#__PURE__*/React__default["default"].createElement("div", {
+      className: addActionClass
+    }, renderAction(addAction)));
+  }
+  return {
+    render: render,
+    type: "array"
+  };
+}
+function createDefaultGroupRenderer(options) {
+  var _ref5 = options != null ? options : {},
+    className = _ref5.className,
+    _ref5$gridStyles = _ref5.gridStyles,
+    gridStyles = _ref5$gridStyles === void 0 ? defaultGridStyles : _ref5$gridStyles,
+    _ref5$defaultGridColu = _ref5.defaultGridColumns,
+    defaultGridColumns = _ref5$defaultGridColu === void 0 ? 2 : _ref5$defaultGridColu,
+    gridClassName = _ref5.gridClassName,
+    standardClassName = _ref5.standardClassName;
+  function defaultGridStyles(_ref6) {
+    var _ref6$columns = _ref6.columns,
+      columns = _ref6$columns === void 0 ? defaultGridColumns : _ref6$columns;
+    return {
+      className: gridClassName,
+      style: {
+        display: "grid",
+        gridTemplateColumns: "repeat(" + columns + ", 1fr)"
+      }
+    };
+  }
+  function render(props) {
+    var childCount = props.childCount,
+      renderChild = props.renderChild,
+      renderOptions = props.renderOptions;
+    var _ref7 = isGridRenderer(renderOptions) ? gridStyles(renderOptions) : {
+        className: standardClassName
+      },
+      style = _ref7.style,
+      gcn = _ref7.className;
+    return /*#__PURE__*/React__default["default"].createElement("div", {
+      className: clsx__default["default"](className, gcn),
+      style: style
+    }, Array.from({
+      length: childCount
+    }, function (_, x) {
+      return renderChild(x);
+    }));
+  }
+  return {
+    type: "group",
+    render: render
+  };
+}
+function createDefaultDisplayRenderer(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    render: function render(_ref8) {
+      var data = _ref8.data;
+      switch (data.type) {
+        case exports.DisplayDataType.Text:
+          return /*#__PURE__*/React__default["default"].createElement("div", {
+            className: options.textClassName
+          }, data.text);
+        case exports.DisplayDataType.Html:
+          return /*#__PURE__*/React__default["default"].createElement("div", {
+            className: options.htmlClassName,
+            dangerouslySetInnerHTML: {
+              __html: data.html
+            }
+          });
+        default:
+          return /*#__PURE__*/React__default["default"].createElement("h1", null, "Unknown display type: ", data.type);
+      }
+    },
+    type: "display"
+  };
+}
+var DefaultBoolOptions = [{
+  name: "Yes",
+  value: true
+}, {
+  name: "No",
+  value: false
+}];
+function createDefaultDataRenderer(options) {
+  var _options$selectOption;
+  if (options === void 0) {
+    options = {};
+  }
+  var selectRenderer = createSelectRenderer((_options$selectOption = options.selectOptions) != null ? _options$selectOption : {});
+  var _optionRenderer$boole = _extends({
+      optionRenderer: selectRenderer,
+      booleanOptions: DefaultBoolOptions
+    }, options),
+    inputClass = _optionRenderer$boole.inputClass,
+    booleanOptions = _optionRenderer$boole.booleanOptions,
+    optionRenderer = _optionRenderer$boole.optionRenderer;
+  return createDataRenderer(function (props, asArray, renderers) {
+    if (asArray) {
+      return asArray();
+    }
+    var renderType = props.renderOptions.type;
+    var fieldType = props.field.type;
+    if (fieldType == exports.FieldType.Any) return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, "No control for Any");
+    var isBool = fieldType === exports.FieldType.Bool;
+    if (booleanOptions != null && isBool && props.options == null) {
+      return renderers.renderData(_extends({}, props, {
+        options: booleanOptions
+      }), undefined);
+    }
+    if (renderType === exports.DataRenderType.Standard && hasOptions(props)) {
+      return optionRenderer.render(props, undefined, renderers);
+    }
+    switch (renderType) {
+      case exports.DataRenderType.Dropdown:
+        return selectRenderer.render(props, undefined, renderers);
+    }
+    return renderType === exports.DataRenderType.Checkbox ? /*#__PURE__*/React__default["default"].createElement(core.Fcheckbox, {
+      control: props.control
+    }) : /*#__PURE__*/React__default["default"].createElement(ControlInput, {
+      className: inputClass,
+      id: props.id,
+      readOnly: props.readonly,
+      control: props.control,
+      convert: createInputConversion(props.field.type)
+    });
+  });
+}
+function ControlInput(_ref9) {
+  var _effect = core.useComponentTracking();
+  try {
+    var control = _ref9.control,
+      convert = _ref9.convert,
+      props = _objectWithoutPropertiesLoose(_ref9, _excluded);
+    var _formControlProps = core.formControlProps(control),
+      errorText = _formControlProps.errorText,
+      value = _formControlProps.value,
+      onChange = _formControlProps.onChange,
+      inputProps = _objectWithoutPropertiesLoose(_formControlProps, _excluded2);
+    return /*#__PURE__*/React__default["default"].createElement("input", _extends({}, inputProps, {
+      type: convert[0],
+      value: value == null ? "" : convert[2](value),
+      onChange: function onChange(e) {
+        control.value = convert[1](e.target.value);
+      }
+    }, props));
+  } finally {
+    _effect();
+  }
+}
+function createDefaultAdornmentRenderer(options) {
+  return {
+    type: "adornment",
+    render: function render(_ref10) {
+      var adornment = _ref10.adornment;
+      return {
+        apply: function apply() {},
+        priority: 0,
+        adornment: adornment
+      };
+    }
+  };
+}
+function createDefaultRenderers(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return {
+    data: createDefaultDataRenderer(options.data),
+    display: createDefaultDisplayRenderer(options.display),
+    action: createDefaultActionRenderer(options.action),
+    array: createDefaultArrayRenderer(options.array),
+    group: createDefaultGroupRenderer(options.group),
+    label: createDefaultLabelRenderer(options.label),
+    adornment: createDefaultAdornmentRenderer(),
+    renderLayout: createDefaultLayoutRenderer(options.layout),
+    visibility: createDefaultVisibilityRenderer()
+  };
+}
+function createDefaultLayoutRenderer(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return createLayoutRenderer(function (props, renderers) {
+    return /*#__PURE__*/React__default["default"].createElement(DefaultLayout, _extends({
+      errorControl: props.errorControl,
+      layout: renderLayoutParts(props, renderers)
+    }, options));
+  });
+}
+function createClassStyledRenderers() {
+  return createDefaultRenderers({
+    layout: {
+      className: "control"
+    },
+    group: {
+      className: "group"
+    },
+    array: {
+      className: "control-array"
+    },
+    action: {
+      className: "action"
+    },
+    data: {
+      inputClass: "data"
+    },
+    display: {
+      htmlClassName: "html",
+      textClassName: "text"
+    }
+  });
+}
+function isAdornmentRegistration(x) {
+  return x.type === "adornment";
+}
+function isDataRegistration(x) {
+  return x.type === "data";
+}
+function isGroupRegistration(x) {
+  return x.type === "group";
+}
+function isLabelRegistration(x) {
+  return x.type === "label";
+}
+function isLayoutRegistration(x) {
+  return x.type === "layout";
+}
+function isVisibilityRegistration(x) {
+  return x.type === "visibility";
+}
+function isActionRegistration(x) {
+  return x.type === "action";
+}
+function isDisplayRegistration(x) {
+  return x.type === "display";
+}
+function isArrayRegistration(x) {
+  return x.type === "array";
+}
+function isOneOf(x, v) {
+  return x == null ? true : Array.isArray(x) ? x.includes(v) : v === x;
+}
+function createLayoutRenderer(render, options) {
+  return _extends({
+    type: "layout",
+    render: render
+  }, options);
+}
+function createArrayRenderer(render, options) {
+  return _extends({
+    type: "array",
+    render: render
+  }, options);
+}
+function createDataRenderer(render, options) {
+  return _extends({
+    type: "data",
+    render: render
+  }, options);
+}
+function createLabelRenderer(render, options) {
+  return _extends({
+    type: "label",
+    render: render
+  }, options);
+}
+function createVisibilityRenderer(render, options) {
+  return _extends({
+    type: "visibility",
+    render: render
+  }, options);
+}
+function createAdornmentRenderer(render, options) {
+  return _extends({
+    type: "adornment"
+  }, options, {
+    render: render
+  });
+}
+function createSelectRenderer(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return createDataRenderer(function (props, asArray) {
+    return /*#__PURE__*/React__default["default"].createElement(SelectDataRenderer, {
+      className: options.className,
+      state: props.control,
+      id: props.id,
+      options: props.options,
+      required: props.required,
+      emptyText: options.emptyText,
+      requiredText: options.requiredText,
+      convert: createSelectConversion(props.field.type)
+    });
+  }, {
+    options: true
+  });
+}
+function SelectDataRenderer(_ref11) {
+  var _effect2 = core.useComponentTracking();
+  try {
+    var state = _ref11.state,
+      options = _ref11.options,
+      className = _ref11.className,
+      convert = _ref11.convert,
+      required = _ref11.required,
+      _ref11$emptyText = _ref11.emptyText,
+      emptyText = _ref11$emptyText === void 0 ? "N/A" : _ref11$emptyText,
+      _ref11$requiredText = _ref11.requiredText,
+      requiredText = _ref11$requiredText === void 0 ? "<please select>" : _ref11$requiredText,
+      props = _objectWithoutPropertiesLoose(_ref11, _excluded3);
+    var value = state.value,
+      disabled = state.disabled;
+    var _useState = React.useState(!required || value == null),
+      showEmpty = _useState[0];
+    var optionStringMap = React.useMemo(function () {
+      return Object.fromEntries(options.map(function (x) {
+        return [convert(x.value), x.value];
+      }));
+    }, [options]);
+    return /*#__PURE__*/React__default["default"].createElement("select", _extends({}, props, {
+      className: className,
+      onChange: function onChange(v) {
+        return state.value = optionStringMap[v.target.value];
+      },
+      value: convert(value),
+      disabled: disabled
+    }), showEmpty && /*#__PURE__*/React__default["default"].createElement("option", {
+      value: ""
+    }, required ? requiredText : emptyText), options.map(function (x, i) {
+      return /*#__PURE__*/React__default["default"].createElement("option", {
+        key: i,
+        value: convert(x.value),
+        disabled: x.disabled
+      }, x.name);
+    }));
+  } finally {
+    _effect2();
+  }
+}
+function createSelectConversion(ft) {
+  switch (ft) {
+    case exports.FieldType.String:
+    case exports.FieldType.Int:
+    case exports.FieldType.Double:
+      return function (a) {
+        return a;
+      };
+    default:
+      return function (a) {
+        var _a$toString;
+        return (_a$toString = a == null ? void 0 : a.toString()) != null ? _a$toString : "";
+      };
+  }
+}
+function createInputConversion(ft) {
+  switch (ft) {
+    case exports.FieldType.String:
+      return ["text", function (a) {
+        return a;
+      }, function (a) {
+        return a;
+      }];
+    case exports.FieldType.Bool:
+      return ["text", function (a) {
+        return a === "true";
+      }, function (a) {
+        var _a$toString2;
+        return (_a$toString2 = a == null ? void 0 : a.toString()) != null ? _a$toString2 : "";
+      }];
+    case exports.FieldType.Int:
+      return ["number", function (a) {
+        return a !== "" ? parseInt(a) : null;
+      }, function (a) {
+        return a == null ? "" : a;
+      }];
+    case exports.FieldType.Date:
+      return ["date", function (a) {
+        return a;
+      }, function (a) {
+        return a;
+      }];
+    case exports.FieldType.Double:
+      return ["number", function (a) {
+        return parseFloat(a);
+      }, function (a) {
+        return a;
+      }];
+    default:
+      return ["text", function (a) {
+        return a;
+      }, function (a) {
+        return a;
+      }];
+  }
+}
+function createDefaultVisibilityRenderer() {
+  return createVisibilityRenderer(function (cv, ch) {
+    return /*#__PURE__*/React__default["default"].createElement(DefaultVisibility, {
+      visibility: cv,
+      children: ch
+    });
+  });
+}
+function DefaultVisibility(_ref12) {
+  var _effect3 = core.useComponentTracking();
+  try {
+    var visibility = _ref12.visibility,
+      children = _ref12.children;
+    var v = visibility.value;
+    React.useEffect(function () {
+      if (v) {
+        visibility.setValue(function (ex) {
+          return {
+            visible: v.visible,
+            showing: v.visible
+          };
+        });
+      }
+    }, [v == null ? void 0 : v.visible]);
+    return v != null && v.visible ? children() : /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null);
+  } finally {
+    _effect3();
+  }
+}
+function DefaultLayout(_ref13) {
+  var _effect4 = core.useComponentTracking();
+  try {
+    var className = _ref13.className,
+      errorClass = _ref13.errorClass,
+      errorControl = _ref13.errorControl,
+      _ref13$layout = _ref13.layout,
+      controlEnd = _ref13$layout.controlEnd,
+      controlStart = _ref13$layout.controlStart,
+      label = _ref13$layout.label,
+      children = _ref13$layout.children;
+    var ec = errorControl;
+    var errorText = ec && ec.touched ? ec.error : undefined;
+    var refCb = React.useCallback(function (e) {
+      if (ec) ec.meta.scrollElement = e;
+    }, [ec]);
+    return /*#__PURE__*/React__default["default"].createElement("div", {
+      className: className,
+      ref: refCb
+    }, label, controlStart, children, errorText && /*#__PURE__*/React__default["default"].createElement("div", {
+      className: errorClass
+    }, errorText), controlEnd);
+  } finally {
+    _effect4();
+  }
+}
+
+var defaultTailwindTheme = {
+  label: {
+    groupLabelClass: "font-bold",
+    requiredElement: /*#__PURE__*/React__default["default"].createElement("span", {
+      className: "text-red-500"
+    }, " *")
+  },
+  array: {
+    removableClass: "grid grid-cols-[1fr_auto] items-center gap-x-2",
+    childClass: "grow my-2",
+    addActionClass: "my-2"
+  },
+  group: {
+    standardClassName: "space-y-4",
+    gridClassName: "gap-x-2 gap-y-4"
+  },
+  action: {
+    className: "bg-primary rounded-lg p-3 text-white"
+  },
+  layout: {
+    className: "flex flex-col",
+    errorClass: "text-sm text-danger-500"
+  }
 };
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./types"), exports);
-__exportStar(require("./schemaBuilder"), exports);
-__exportStar(require("./controlRender"), exports);
-__exportStar(require("./hooks"), exports);
+
+exports.AppendAdornmentPriority = AppendAdornmentPriority;
+exports.ControlInput = ControlInput;
+exports.DefaultBoolOptions = DefaultBoolOptions;
+exports.DefaultLayout = DefaultLayout;
+exports.DefaultVisibility = DefaultVisibility;
+exports.SelectDataRenderer = SelectDataRenderer;
+exports.WrapAdornmentPriority = WrapAdornmentPriority;
+exports.addMissingControls = addMissingControls;
+exports.appendMarkup = appendMarkup;
+exports.appendMarkupAt = appendMarkupAt;
+exports.applyDefaultForField = applyDefaultForField;
+exports.applyDefaultValues = applyDefaultValues;
+exports.boolField = boolField;
+exports.buildSchema = buildSchema;
+exports.cleanDataForSchema = cleanDataForSchema;
+exports.compoundControl = compoundControl;
+exports.compoundField = compoundField;
+exports.controlTitle = controlTitle;
+exports.createAction = createAction;
+exports.createAdornmentRenderer = createAdornmentRenderer;
+exports.createArrayRenderer = createArrayRenderer;
+exports.createDataRenderer = createDataRenderer;
+exports.createDefaultActionRenderer = createDefaultActionRenderer;
+exports.createDefaultAdornmentRenderer = createDefaultAdornmentRenderer;
+exports.createDefaultArrayRenderer = createDefaultArrayRenderer;
+exports.createDefaultDataRenderer = createDefaultDataRenderer;
+exports.createDefaultDisplayRenderer = createDefaultDisplayRenderer;
+exports.createDefaultGroupRenderer = createDefaultGroupRenderer;
+exports.createDefaultLabelRenderer = createDefaultLabelRenderer;
+exports.createDefaultRenderers = createDefaultRenderers;
+exports.createDefaultVisibilityRenderer = createDefaultVisibilityRenderer;
+exports.createFormRenderer = createFormRenderer;
+exports.createInputConversion = createInputConversion;
+exports.createLabelRenderer = createLabelRenderer;
+exports.createLayoutRenderer = createLayoutRenderer;
+exports.createSelectConversion = createSelectConversion;
+exports.createSelectRenderer = createSelectRenderer;
+exports.createVisibilityRenderer = createVisibilityRenderer;
+exports.dataControl = dataControl;
+exports.defaultCompoundField = defaultCompoundField;
+exports.defaultControlForField = defaultControlForField;
+exports.defaultDataProps = defaultDataProps;
+exports.defaultScalarField = defaultScalarField;
+exports.defaultTailwindTheme = defaultTailwindTheme;
+exports.defaultValueForField = defaultValueForField;
+exports.defaultValueForFields = defaultValueForFields;
+exports.dynamicDefaultValue = dynamicDefaultValue;
+exports.elementValueForField = elementValueForField;
+exports.emptyGroupDefinition = emptyGroupDefinition;
+exports.fieldDisplayName = fieldDisplayName;
+exports.fieldEqExpr = fieldEqExpr;
+exports.fieldHasTag = fieldHasTag;
+exports.findCompoundField = findCompoundField;
+exports.findField = findField;
+exports.findScalarField = findScalarField;
+exports.getControlData = getControlData;
+exports.getTypeField = getTypeField;
+exports.groupedControl = groupedControl;
+exports.hasOptions = hasOptions;
+exports.htmlDisplayControl = htmlDisplayControl;
+exports.intField = intField;
+exports.isActionControlsDefinition = isActionControlsDefinition;
+exports.isCompoundField = isCompoundField;
+exports.isDataControl = isDataControl;
+exports.isDataControlDefinition = isDataControlDefinition;
+exports.isDisplayControlsDefinition = isDisplayControlsDefinition;
+exports.isGridRenderer = isGridRenderer;
+exports.isGroupControl = isGroupControl;
+exports.isGroupControlsDefinition = isGroupControlsDefinition;
+exports.isScalarField = isScalarField;
+exports.jsonataExpr = jsonataExpr;
+exports.layoutKeyForPlacement = layoutKeyForPlacement;
+exports.lookupSchemaField = lookupSchemaField;
+exports.makeCompoundField = makeCompoundField;
+exports.makeScalarField = makeScalarField;
+exports.renderControlLayout = renderControlLayout;
+exports.renderLayoutParts = renderLayoutParts;
+exports.stringField = stringField;
+exports.stringOptionsField = stringOptionsField;
+exports.textDisplayControl = textDisplayControl;
+exports.useControlDefinitionForSchema = useControlDefinitionForSchema;
+exports.useControlRenderer = useControlRenderer;
+exports.useUpdatedRef = useUpdatedRef;
+exports.useValidationHook = useValidationHook;
+exports.visibility = visibility;
+exports.visitControlData = visitControlData;
+exports.visitControlDataArray = visitControlDataArray;
+exports.visitControlDefinition = visitControlDefinition;
+exports.withScalarOptions = withScalarOptions;
+exports.wrapMarkup = wrapMarkup;
+exports.wrapMarkupAt = wrapMarkupAt;
+//# sourceMappingURL=index.js.map