@react-typed-forms/schemas 1.0.0-dev.17 → 1.0.0-dev.19

package/lib/index.js

@@ -1,9 +1,13 @@
 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);
 
 function _extends() {
   _extends = Object.assign ? Object.assign.bind() : function (target) {
@@ -19,6 +23,49 @@ function _extends() {
   };
   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.");
+}
 
 exports.FieldType = void 0;
 (function (FieldType) {
@@ -52,10 +99,18 @@ exports.ExpressionType = void 0;
   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) {
@@ -68,6 +123,8 @@ exports.DataRenderType = void 0;
   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) {
@@ -86,6 +143,16 @@ exports.DisplayDataType = void 0;
   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;
 }
@@ -131,6 +198,9 @@ function visibility(expr) {
     expr: expr
   };
 }
+function isGridRenderer(options) {
+  return options.type === exports.GroupRenderType.Grid;
+}
 
 function buildSchema(def) {
   return Object.entries(def).map(function (x) {
@@ -206,50 +276,6 @@ function defaultCompoundField(field, displayName, collection) {
   };
 }
 
-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;
-}
-
-var _FormRendererComponentsContext = null;
-function FormRendererComponentsContext() {
-  if (!_FormRendererComponentsContext) {
-    _FormRendererComponentsContext = React.createContext(undefined);
-  }
-  return _FormRendererComponentsContext;
-}
-function FormRendererProvider(_ref) {
-  var _effect = core.useComponentTracking();
-  try {
-    var value = _ref.value,
-      children = _ref.children;
-    var _FormRendererComponen = FormRendererComponentsContext(),
-      Provider = _FormRendererComponen.Provider;
-    return /*#__PURE__*/React__default["default"].createElement(Provider, {
-      value: value,
-      children: children
-    });
-  } finally {
-    _effect();
-  }
-}
-function useFormRendererComponents() {
-  var c = React.useContext(FormRendererComponentsContext());
-  if (!c) {
-    throw "Need to use FormRendererComponentContext.Provider";
-  }
-  return c;
-}
-function isScalarField(sf) {
-  return !isCompoundField(sf);
-}
-function isCompoundField(sf) {
-  return sf.type === exports.FieldType.Compound;
-}
 function applyDefaultValues(v, fields) {
   if (!v) return defaultValueForFields(fields);
   var applyValue = fields.filter(function (x) {
@@ -303,18 +329,142 @@ function findField(fields, field) {
     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)) {
+    if (control.compoundField) return field === control.compoundField ? control : undefined;
+    return findReferencedControlInArray(field, 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 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)
+    });
+  });
+  return changedCompounds.concat(changes.filter(function (x) {
+    return !x.existing;
+  }).map(function (x) {
+    return defaultControlForField(x.field);
+  }));
+}
+
+var _FormRendererComponentsContext = null;
+function FormRendererComponentsContext() {
+  if (!_FormRendererComponentsContext) {
+    _FormRendererComponentsContext = React.createContext(undefined);
+  }
+  return _FormRendererComponentsContext;
+}
+function FormRendererProvider(_ref) {
+  var _effect = core.useComponentTracking();
+  try {
+    var value = _ref.value,
+      children = _ref.children;
+    var _FormRendererComponen = FormRendererComponentsContext(),
+      Provider = _FormRendererComponen.Provider;
+    return /*#__PURE__*/React__default["default"].createElement(Provider, {
+      value: value,
+      children: children
+    });
+  } finally {
+    _effect();
+  }
+}
+function useFormRendererComponents() {
+  var c = React.useContext(FormRendererComponentsContext());
+  if (!c) {
+    throw "Need to use FormRendererComponentContext.Provider";
+  }
+  return c;
+}
 function controlTitle(title, field) {
   return title ? title : fieldDisplayName(field);
 }
-function renderControl(definition, formState, hooks, key, wrapChild) {
+function renderControl(definition, formState, hooks, key) {
   var fields = formState.fields;
   return visitControlDefinition(definition, {
     data: function data(def) {
       var fieldData = findScalarField(fields, def.field);
-      if (!fieldData) return /*#__PURE__*/React__default["default"].createElement("h1", null, "No schema field for: ", def.field);
+      if (!fieldData) return /*#__PURE__*/React__default["default"].createElement("h1", {
+        key: key
+      }, "No schema field for: ", def.field);
       return /*#__PURE__*/React__default["default"].createElement(DataRenderer, {
         key: key,
-        wrapElem: wrapElem,
         formState: formState,
         hooks: hooks,
         controlDef: def,
@@ -326,8 +476,7 @@ function renderControl(definition, formState, hooks, key, wrapChild) {
         key: key,
         hooks: hooks,
         groupDef: d,
-        formState: formState,
-        wrapElem: wrapElem
+        formState: formState
       });
     },
     action: function action(d) {
@@ -335,7 +484,6 @@ function renderControl(definition, formState, hooks, key, wrapChild) {
         key: key,
         hooks: hooks,
         formState: formState,
-        wrapElem: wrapElem,
         actionDef: d
       });
     },
@@ -344,17 +492,12 @@ function renderControl(definition, formState, hooks, key, wrapChild) {
         key: key,
         hooks: hooks,
         formState: formState,
-        wrapElem: wrapElem,
         displayDef: d
       });
     }
   }, function () {
     return /*#__PURE__*/React__default["default"].createElement("h1", null, "Unknown control: ", definition.type);
   });
-  function wrapElem(e) {
-    var _wrapChild;
-    return (_wrapChild = wrapChild == null ? void 0 : wrapChild(key, e)) != null ? _wrapChild : e;
-  }
 }
 /** @trackControls */
 function DataRenderer(_ref2) {
@@ -364,17 +507,10 @@ function DataRenderer(_ref2) {
     var hooks = _ref2.hooks,
       formState = _ref2.formState,
       controlDef = _ref2.controlDef,
-      wrapElem = _ref2.wrapElem,
       fieldData = _ref2.fieldData;
     var renderer = useFormRendererComponents();
-    var props = hooks.useDataProperties(formState, controlDef, fieldData);
-    var scalarProps = {
-      formEditState: formState,
-      field: fieldData,
-      definition: controlDef,
-      properties: props
-    };
-    return wrapElem(((_props$customRender = props.customRender) != null ? _props$customRender : renderer.renderData)(scalarProps, props.control, false, renderer));
+    var props = hooks.useDataProperties(formState, controlDef, fieldData, renderer);
+    return ((_props$customRender = props.customRender) != null ? _props$customRender : renderer.renderData)(props);
   } finally {
     _effect2();
   }
@@ -385,15 +521,11 @@ function ActionRenderer(_ref3) {
   try {
     var hooks = _ref3.hooks,
       formState = _ref3.formState,
-      wrapElem = _ref3.wrapElem,
       actionDef = _ref3.actionDef;
     var _useFormRendererCompo = useFormRendererComponents(),
       renderAction = _useFormRendererCompo.renderAction;
     var actionControlProperties = hooks.useActionProperties(formState, actionDef);
-    return wrapElem(renderAction({
-      definition: actionDef,
-      properties: actionControlProperties
-    }));
+    return renderAction(actionControlProperties);
   } finally {
     _effect3();
   }
@@ -404,32 +536,10 @@ function GroupRenderer(_ref4) {
   try {
     var hooks = _ref4.hooks,
       formState = _ref4.formState,
-      groupDef = _ref4.groupDef,
-      wrapElem = _ref4.wrapElem;
+      groupDef = _ref4.groupDef;
     var renderers = useFormRendererComponents();
-    var groupProps = hooks.useGroupProperties(formState, groupDef, hooks);
-    var compoundField = groupDef.compoundField ? findCompoundField(formState.fields, groupDef.compoundField) : undefined;
-    if (compoundField) {
-      return wrapElem(renderers.renderCompound({
-        definition: groupDef,
-        field: compoundField,
-        properties: groupProps,
-        renderChild: function renderChild(k, c, data, wrapChild) {
-          return renderControl(c, _extends({}, formState, {
-            fields: compoundField.children,
-            data: data
-          }), groupProps.hooks, k, wrapChild);
-        }
-      }, formState.data.fields[compoundField.field], renderers));
-    }
-    return wrapElem(renderers.renderGroup({
-      definition: groupDef,
-      childCount: groupDef.children.length,
-      properties: groupProps,
-      renderChild: function renderChild(c, wrapChild) {
-        return renderControl(groupDef.children[c], formState, groupProps.hooks, c, wrapChild);
-      }
-    }));
+    var groupProps = hooks.useGroupProperties(formState, groupDef, hooks, renderers);
+    return renderers.renderGroup(groupProps);
   } finally {
     _effect4();
   }
@@ -439,16 +549,12 @@ function DisplayRenderer(_ref5) {
   var _effect5 = core.useComponentTracking();
   try {
     var hooks = _ref5.hooks,
-      wrapElem = _ref5.wrapElem,
       formState = _ref5.formState,
       displayDef = _ref5.displayDef;
     var _useFormRendererCompo2 = useFormRendererComponents(),
       renderDisplay = _useFormRendererCompo2.renderDisplay;
     var displayProps = hooks.useDisplayProperties(formState, displayDef);
-    return wrapElem(renderDisplay({
-      definition: displayDef,
-      properties: displayProps
-    }));
+    return renderDisplay(displayProps);
   } finally {
     _effect5();
   }
@@ -461,30 +567,80 @@ function controlForField(field, formState) {
 function fieldForControl(c) {
   return isDataControl(c) ? c.field : isGroupControl(c) ? c.compoundField : undefined;
 }
-function isDataControl(c) {
-  return c.type === exports.ControlDefinitionType.Data;
+var AlwaysVisible = {
+  value: true,
+  canChange: false
+};
+function createAction(label, onClick, actionId) {
+  return {
+    definition: {
+      type: exports.ControlDefinitionType.Action,
+      actionId: actionId != null ? actionId : label,
+      title: label
+    },
+    visible: AlwaysVisible,
+    onClick: onClick
+  };
 }
-function isGroupControl(c) {
-  return c.type === exports.ControlDefinitionType.Group;
+function visitControlData(definition, _ref7, cb) {
+  var fields = _ref7.fields,
+    _data = _ref7.data;
+  return visitControlDefinition(definition, {
+    data: function data(def) {
+      var fieldData = findScalarField(fields, def.field);
+      if (!fieldData) return undefined;
+      return cb(def, _data.fields[fieldData.field]);
+    },
+    group: function group(d) {
+      if (d.compoundField) {
+        var compound = findCompoundField(fields, d.compoundField);
+        if (!compound) return;
+        fields = compound.children;
+        _data = _data.fields[compound.field];
+      }
+      var childState = {
+        fields: fields,
+        data: _data
+      };
+      for (var _iterator = _createForOfIteratorHelperLoose(d.children), _step; !(_step = _iterator()).done;) {
+        var c = _step.value;
+        var res = visitControlData(c, childState, cb);
+        if (res !== undefined) return res;
+      }
+      return undefined;
+    },
+    action: function action(d) {
+      return undefined;
+    },
+    display: function display(d) {
+      return undefined;
+    }
+  }, function () {
+    return undefined;
+  });
 }
 
-function useDefaultValue(definition, field, formState, useExpression) {
+function useDefaultValue(definition, field, formState, hooks) {
   var _definition$dynamic;
   var valueExpression = (_definition$dynamic = definition.dynamic) == null ? void 0 : _definition$dynamic.find(function (x) {
     return x.type === exports.DynamicPropertyType.DefaultValue;
   });
   if (valueExpression) {
-    return useExpression(valueExpression.expr, formState);
+    return hooks.useExpression(valueExpression.expr, formState).value;
   }
   return field.defaultValue;
 }
-function useIsControlVisible(definition, formState, useExpression) {
-  var _definition$dynamic2, _ref2;
+function useIsControlVisible(definition, formState, hooks) {
+  var _definition$dynamic2, _ref2, _onlyForTypes$length;
   var visibleExpression = (_definition$dynamic2 = definition.dynamic) == null ? void 0 : _definition$dynamic2.find(function (x) {
     return x.type === exports.DynamicPropertyType.Visible;
   });
   if (visibleExpression && visibleExpression.expr) {
-    return Boolean(useExpression(visibleExpression.expr, formState));
+    var exprValue = hooks.useExpression(visibleExpression.expr, formState).value;
+    return {
+      value: Boolean(exprValue),
+      canChange: true
+    };
   }
   var schemaFields = formState.fields;
   var _useMemo = React.useMemo(function () {
@@ -503,74 +659,886 @@ function useIsControlVisible(definition, formState, useExpression) {
     compoundField = _useMemo.compoundField;
   var fieldName = fieldForControl(definition);
   var onlyForTypes = (_ref2 = fieldName ? findField(schemaFields, fieldName) : undefined) == null ? void 0 : _ref2.onlyForTypes;
-  return (!compoundField || compoundField.value != null) && (!onlyForTypes || onlyForTypes.length === 0 || Boolean(typeControl.value && onlyForTypes.includes(typeControl.value)));
+  var canChange = Boolean(compoundField || ((_onlyForTypes$length = onlyForTypes == null ? void 0 : onlyForTypes.length) != null ? _onlyForTypes$length : 0) > 0);
+  var value = (!compoundField || compoundField.value != null) && (!onlyForTypes || onlyForTypes.length === 0 || Boolean(typeControl.value && onlyForTypes.includes(typeControl.value)));
+  return {
+    value: value,
+    canChange: canChange
+  };
 }
-function getDefaultScalarControlProperties(definition, field, visible, defaultValue, control, readonly) {
-  var _definition$required, _ref3;
+function getDefaultScalarControlProperties(definition, field, visible, defaultValue, control, formState) {
+  var _definition$renderOpt, _definition$required, _ref3, _formState$readonly;
   return {
+    definition: definition,
+    field: field,
     defaultValue: defaultValue,
     options: getOptionsForScalarField(field),
+    renderOptions: (_definition$renderOpt = definition.renderOptions) != null ? _definition$renderOpt : {
+      type: exports.DataRenderType.Standard
+    },
     required: (_definition$required = definition.required) != null ? _definition$required : false,
     visible: visible,
-    readonly: (_ref3 = readonly != null ? readonly : definition.readonly) != null ? _ref3 : false,
-    control: control
+    readonly: (_ref3 = (_formState$readonly = formState.readonly) != null ? _formState$readonly : definition.readonly) != null ? _ref3 : false,
+    control: control,
+    formState: formState
   };
 }
 function getOptionsForScalarField(field) {
-  var _field$options, _field$restrictions, _opts$length;
-  var opts = (_field$options = field.options) != null ? _field$options : (_field$restrictions = field.restrictions) == null ? void 0 : _field$restrictions.options;
+  var _opts$length;
+  var opts = field.options;
   if ((_opts$length = opts == null ? void 0 : opts.length) != null ? _opts$length : 0 > 0) {
     return opts;
   }
   return undefined;
 }
-var defaultExpressionHook = function defaultExpressionHook(expr, formState) {
-  switch (expr.type) {
-    case exports.ExpressionType.FieldValue:
-      var fvExpr = expr;
-      return controlForField(fvExpr.field, formState).value === fvExpr.value;
-    default:
-      return undefined;
+function createDefaultSchemaHooks() {
+  function useExpression(expr, formState) {
+    switch (expr.type) {
+      case exports.ExpressionType.Jsonata:
+        var jExpr = expr;
+        var compiledExpr = React.useMemo(function () {
+          return jsonata__default["default"](jExpr.expression);
+        }, [jExpr.expression]);
+        var control = core.useControl();
+        core.useControlEffect(function () {
+          return formState.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);
+          }
+        });
+        return control;
+      case exports.ExpressionType.FieldValue:
+        var fvExpr = expr;
+        return core.useComputed(function () {
+          var fv = controlForField(fvExpr.field, formState).value;
+          return Array.isArray(fv) ? fv.includes(fvExpr.value) : fv === fvExpr.value;
+        });
+      default:
+        return core.useControl(undefined);
+    }
+  }
+  function useValidators(formState, isVisible, control, required, validators) {
+    if (required) core.useValidator(control, function (v) {
+      return isVisible && (v == null || v == "") ? "Please enter a value" : null;
+    }, "required");
+    validators == null || validators.forEach(function (v, i) {
+      switch (v.type) {
+        case exports.ValidatorType.Date:
+          processDateValidator(v);
+          break;
+        case exports.ValidatorType.Jsonata:
+          var errorMsg = useExpression(v, formState);
+          core.useControlEffect(function () {
+            return [isVisible, errorMsg.value];
+          }, function (_ref4) {
+            var isVisible = _ref4[0],
+              msg = _ref4[1];
+            return control.setError(v.type + i, isVisible ? msg : null);
+          }, true);
+          break;
+      }
+      function processDateValidator(dv) {
+        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);
+      }
+    });
   }
-};
-function createFormEditHooks(useExpression) {
   return {
     useExpression: useExpression,
-    useDataProperties: function useDataProperties(formState, definition, field) {
-      var visible = useIsControlVisible(definition, formState, useExpression);
-      var defaultValue = useDefaultValue(definition, field, formState, useExpression);
+    useValidators: useValidators
+  };
+}
+var defaultFormEditHooks = createFormEditHooks(createDefaultSchemaHooks());
+function createFormEditHooks(schemaHooks) {
+  return {
+    schemaHooks: schemaHooks,
+    useDataProperties: function useDataProperties(formState, definition, field, renderer) {
+      var visible = useIsControlVisible(definition, formState, schemaHooks);
+      var isVisible = visible.value && !formState.invisible;
+      var defaultValue = useDefaultValue(definition, field, formState, schemaHooks);
       var scalarControl = formState.data.fields[field.field];
       React.useEffect(function () {
-        if (!visible) scalarControl.value = null;else if (scalarControl.current.value == null) {
+        if (!isVisible) scalarControl.value = null;else if (scalarControl.current.value == null) {
           scalarControl.value = defaultValue;
         }
-      }, [visible, defaultValue]);
-      return getDefaultScalarControlProperties(definition, field, visible, defaultValue, scalarControl, formState.readonly);
+      }, [isVisible, defaultValue]);
+      var dataProps = getDefaultScalarControlProperties(definition, field, visible, defaultValue, scalarControl, formState);
+      schemaHooks.useValidators(formState, isVisible, scalarControl, dataProps.required, definition.validators);
+      React.useEffect(function () {
+        var subscription = scalarControl.subscribe(function (c) {
+          return c.touched = true;
+        }, core.ControlChange.Validate);
+        return function () {
+          return scalarControl.unsubscribe(subscription);
+        };
+      }, []);
+      if (!field.collection) return dataProps;
+      return _extends({}, dataProps, {
+        array: defaultArrayRendererProps(scalarControl, field, definition, dataProps.readonly, function (c) {
+          return renderer.renderData(_extends({}, dataProps, {
+            control: c
+          }));
+        })
+      });
     },
     useDisplayProperties: function useDisplayProperties(fs, definition) {
-      var visible = useIsControlVisible(definition, fs, useExpression);
+      var visible = useIsControlVisible(definition, fs, schemaHooks);
       return {
-        visible: visible
+        visible: visible,
+        definition: definition
       };
     },
-    useGroupProperties: function useGroupProperties(fs, definition, hooks) {
-      var visible = useIsControlVisible(definition, fs, useExpression);
-      return {
+    useGroupProperties: function useGroupProperties(fs, definition, hooks, renderers) {
+      var _definition$groupOpti;
+      var visible = useIsControlVisible(definition, fs, schemaHooks);
+      var field = definition.compoundField ? findCompoundField(fs.fields, definition.compoundField) : undefined;
+      var newFs = _extends({}, fs, {
+        fields: field ? field.children : fs.fields,
+        data: field ? fs.data.fields[field.field] : fs.data,
+        invisible: !visible.value || fs.invisible
+      });
+      var groupProps = {
         visible: visible,
-        hooks: hooks
+        hooks: hooks,
+        hideTitle: (_definition$groupOpti = definition.groupOptions.hideTitle) != null ? _definition$groupOpti : false,
+        childCount: definition.children.length,
+        renderChild: function renderChild(i) {
+          return renderControl(definition.children[i], newFs, hooks, i);
+        },
+        definition: definition
       };
+      if (field != null && field.collection) {
+        return _extends({}, groupProps, {
+          array: defaultArrayRendererProps(newFs.data, field, definition, fs.readonly, function (e) {
+            return renderers.renderGroup(_extends({}, groupProps, {
+              hideTitle: true,
+              renderChild: function renderChild(i) {
+                return renderControl(definition.children[i], _extends({}, newFs, {
+                  data: e
+                }), hooks, i);
+              }
+            }));
+          })
+        });
+      }
+      return groupProps;
     },
     useActionProperties: function useActionProperties(formState, definition) {
-      var visible = useIsControlVisible(definition, formState, useExpression);
+      var visible = useIsControlVisible(definition, formState, schemaHooks);
       return {
         visible: visible,
-        onClick: function onClick() {}
+        onClick: function onClick() {},
+        definition: definition
+      };
+    }
+  };
+}
+function defaultArrayRendererProps(control, field, definition, readonly, renderElem) {
+  var _control$elements$len, _control$elements;
+  return {
+    control: control,
+    childCount: (_control$elements$len = (_control$elements = control.elements) == null ? void 0 : _control$elements.length) != null ? _control$elements$len : 0,
+    field: field,
+    definition: definition,
+    addAction: !readonly ? {
+      definition: {
+        title: "Add " + controlTitle(definition.title, field),
+        type: exports.ControlDefinitionType.Action,
+        actionId: "addElement"
+      },
+      visible: {
+        value: true,
+        canChange: false
+      },
+      onClick: function onClick() {
+        return core.addElement(control, elementValueForField(field));
+      }
+    } : undefined,
+    removeAction: !readonly ? function (i) {
+      return {
+        definition: {
+          title: "Remove",
+          type: exports.ControlDefinitionType.Action,
+          actionId: "removeElement"
+        },
+        visible: {
+          value: true,
+          canChange: false
+        },
+        onClick: function onClick() {
+          return core.removeElement(control, control.elements[i]);
+        }
       };
+    } : undefined,
+    childKey: function childKey(i) {
+      return control.elements[i].uniqueId;
+    },
+    renderChild: function renderChild(i) {
+      var c = control.elements[i];
+      return /*#__PURE__*/React__default["default"].createElement(React.Fragment, {
+        key: c.uniqueId
+      }, renderElem(c));
     }
   };
 }
+function useControlsWithDefaults(definition, sf) {
+  return React.useMemo(function () {
+    return definition.children.length ? definition : _extends({}, definition, {
+      children: addMissingControls(sf, [])
+    });
+  }, [sf, definition]);
+}
+
+var _excluded = ["control", "convert"],
+  _excluded2 = ["errorText", "value", "onChange"],
+  _excluded3 = ["state", "options", "className", "convert", "required", "emptyText", "requiredText"];
+function createFormRenderer(customRenderers, defaultRenderers) {
+  var _customRenderers$find, _customRenderers$find2;
+  if (customRenderers === void 0) {
+    customRenderers = [];
+  }
+  if (defaultRenderers === void 0) {
+    defaultRenderers = createClassStyledRenderers();
+  }
+  var dataRegistrations = customRenderers.filter(isDataRegistration);
+  var adornmentRegistrations = customRenderers.filter(isAdornmentRegistration);
+  var labelRenderer = (_customRenderers$find = customRenderers.find(isLabelRegistration)) != null ? _customRenderers$find : defaultRenderers.label;
+  var renderVisibility = ((_customRenderers$find2 = customRenderers.find(isVisibilityRegistration)) != null ? _customRenderers$find2 : defaultRenderers.visibility).render;
+  var formRenderers = {
+    renderAction: renderAction,
+    renderData: _renderData,
+    renderGroup: _renderGroup,
+    renderDisplay: renderDisplay,
+    renderLabel: renderLabel,
+    renderArray: renderArray,
+    renderVisibility: renderVisibility,
+    renderAdornment: renderAdornment
+  };
+  function renderAdornment(props) {
+    var _adornmentRegistratio;
+    var renderer = (_adornmentRegistratio = adornmentRegistrations.find(function (x) {
+      return isOneOf(x.adornmentType, props.definition.type);
+    })) != null ? _adornmentRegistratio : defaultRenderers.adornment;
+    return renderer.render(props);
+  }
+  function renderArray(props) {
+    return defaultRenderers.array.render(props, formRenderers);
+  }
+  function renderLabel(props, elem) {
+    return labelRenderer.render(props, elem, formRenderers);
+  }
+  function withAdornments(definition, adornments) {
+    var _definition$adornment, _definition$adornment2;
+    var rAdornments = adornments ? adornments : (_definition$adornment = (_definition$adornment2 = definition.adornments) == null ? void 0 : _definition$adornment2.map(function (x, i) {
+      return renderAdornment({
+        definition: x,
+        key: i
+      });
+    })) != null ? _definition$adornment : [];
+    function combineAdornments(placement) {
+      return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, rAdornments.filter(function (x) {
+        return x.child && x.child[0] === placement;
+      }).map(function (x) {
+        return x.child[1];
+      }));
+    }
+    return [rAdornments, combineAdornments, function (mainElem) {
+      return !adornments ? mainElem : rAdornments.reduce(function (e, n) {
+        var _n$wrap;
+        return (_n$wrap = n.wrap == null ? void 0 : n.wrap(e)) != null ? _n$wrap : e;
+      }, mainElem);
+    }];
+  }
+  function _renderData(props, adornments) {
+    var _dataRegistrations$fi;
+    var definition = props.definition,
+      renderType = props.renderOptions.type,
+      visible = props.visible,
+      required = props.required,
+      control = props.control,
+      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 _withAdornments = withAdornments(definition, adornments),
+      rAdornments = _withAdornments[0],
+      renderAdornment = _withAdornments[1],
+      wrapElem = _withAdornments[2];
+    return wrapElem(renderer.render(props, createLabel, _extends({}, formRenderers, {
+      renderData: function renderData(p) {
+        return _renderData(p, rAdornments);
+      }
+    })));
+    function createLabel(labelProps) {
+      var _labelProps$title;
+      return _extends({
+        visible: visible,
+        required: required,
+        control: control,
+        forId: "c" + control.uniqueId,
+        renderAdornment: renderAdornment
+      }, labelProps, {
+        title: (_labelProps$title = labelProps == null ? void 0 : labelProps.title) != null ? _labelProps$title : controlTitle(definition.title, field)
+      });
+    }
+  }
+  function _renderGroup(props, adornments) {
+    var definition = props.definition,
+      visible = props.visible,
+      field = props.field;
+    var _withAdornments2 = withAdornments(props.definition, adornments),
+      rAdornments = _withAdornments2[0],
+      renderAdornment = _withAdornments2[1],
+      wrapElem = _withAdornments2[2];
+    var title = props.hideTitle ? undefined : field ? controlTitle(definition.title, field) : definition.title;
+    return wrapElem(defaultRenderers.group.render(props, createLabel, _extends({}, formRenderers, {
+      renderGroup: function renderGroup(p) {
+        return _renderGroup(p, rAdornments);
+      }
+    })));
+    function createLabel(labelProps) {
+      return _extends({
+        required: false,
+        visible: visible,
+        group: true,
+        renderAdornment: renderAdornment,
+        title: title
+      }, labelProps);
+    }
+  }
+  function renderAction(props, adornments) {
+    var _customRenderers$find3;
+    var renderer = (_customRenderers$find3 = customRenderers.find(isActionRegistration)) != null ? _customRenderers$find3 : defaultRenderers.action;
+    var _withAdornments3 = withAdornments(props.definition, adornments),
+      wrapElem = _withAdornments3[2];
+    return wrapElem(renderer.render(props, formRenderers));
+  }
+  function renderDisplay(props, adornments) {
+    var _withAdornments4 = withAdornments(props.definition, adornments),
+      wrapElem = _withAdornments4[2];
+    return wrapElem(defaultRenderers.display.render(props, formRenderers));
+  }
+  return formRenderers;
+}
+function createDefaultActionRenderer(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  function render(_ref, _ref2) {
+    var visible = _ref.visible,
+      onClick = _ref.onClick,
+      title = _ref.definition.title;
+    var renderVisibility = _ref2.renderVisibility;
+    return renderVisibility(visible, /*#__PURE__*/React__default["default"].createElement("button", {
+      className: options.className,
+      onClick: onClick
+    }, title));
+  }
+  return {
+    render: render,
+    type: "action"
+  };
+}
+function createDefaultLabelRenderer(options) {
+  if (options === void 0) {
+    options = {
+      requiredElement: /*#__PURE__*/React__default["default"].createElement("span", null, " *")
+    };
+  }
+  return {
+    render: function render(p, elem, _ref3) {
+      var renderVisibility = _ref3.renderVisibility;
+      return renderVisibility(p.visible, /*#__PURE__*/React__default["default"].createElement(DefaultLabelRenderer, _extends({}, p, options, {
+        children: elem
+      })));
+    },
+    type: "label"
+  };
+}
+function DefaultLabelRenderer(_ref4) {
+  var _effect = core.useComponentTracking();
+  try {
+    var className = _ref4.className,
+      labelClass = _ref4.labelClass,
+      title = _ref4.title,
+      forId = _ref4.forId,
+      required = _ref4.required,
+      children = _ref4.children,
+      group = _ref4.group,
+      groupLabelClass = _ref4.groupLabelClass,
+      renderAdornment = _ref4.renderAdornment,
+      requiredElement = _ref4.requiredElement;
+    return title ? /*#__PURE__*/React__default["default"].createElement("div", {
+      className: className
+    }, renderAdornment(exports.AdornmentPlacement.LabelStart), /*#__PURE__*/React__default["default"].createElement("label", {
+      htmlFor: forId,
+      className: clsx__default["default"](labelClass, group && groupLabelClass)
+    }, title, required && requiredElement), renderAdornment(exports.AdornmentPlacement.LabelEnd), renderAdornment(exports.AdornmentPlacement.ControlStart), children, renderAdornment(exports.AdornmentPlacement.ControlEnd)) : /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null, children);
+  } finally {
+    _effect();
+  }
+}
+function createDefaultArrayRenderer(options) {
+  var _ref5 = options != null ? options : {},
+    className = _ref5.className,
+    removableClass = _ref5.removableClass,
+    childClass = _ref5.childClass,
+    removableChildClass = _ref5.removableChildClass,
+    removeActionClass = _ref5.removeActionClass,
+    addActionClass = _ref5.addActionClass;
+  function render(_ref6, _ref7) {
+    var childCount = _ref6.childCount,
+      renderChild = _ref6.renderChild,
+      addAction = _ref6.addAction,
+      removeAction = _ref6.removeAction,
+      childKey = _ref6.childKey;
+    var renderAction = _ref7.renderAction;
+    return /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, 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
+      }, 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 _ref8 = options != null ? options : {},
+    className = _ref8.className,
+    _ref8$gridStyles = _ref8.gridStyles,
+    gridStyles = _ref8$gridStyles === void 0 ? defaultGridStyles : _ref8$gridStyles,
+    _ref8$defaultGridColu = _ref8.defaultGridColumns,
+    defaultGridColumns = _ref8$defaultGridColu === void 0 ? 2 : _ref8$defaultGridColu,
+    gridClassName = _ref8.gridClassName,
+    standardClassName = _ref8.standardClassName;
+  function defaultGridStyles(_ref9) {
+    var _ref9$columns = _ref9.columns,
+      columns = _ref9$columns === void 0 ? defaultGridColumns : _ref9$columns;
+    return {
+      className: gridClassName,
+      style: {
+        display: "grid",
+        gridTemplateColumns: "repeat(" + columns + ", 1fr)"
+      }
+    };
+  }
+  function render(props, defaultLabel, _ref10) {
+    var renderLabel = _ref10.renderLabel,
+      renderArray = _ref10.renderArray;
+    var childCount = props.childCount,
+      renderChild = props.renderChild,
+      definition = props.definition;
+    return renderLabel(defaultLabel(), props.array ? renderArray(props.array) : renderChildren());
+    function renderChildren() {
+      var groupOptions = definition.groupOptions;
+      var _ref11 = isGridRenderer(groupOptions) ? gridStyles(groupOptions) : {
+          className: standardClassName
+        },
+        style = _ref11.style,
+        gcn = _ref11.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 = {};
+  }
+  function doRender(_ref12) {
+    var displayData = _ref12.definition.displayData;
+    switch (displayData.type) {
+      case exports.DisplayDataType.Text:
+        return /*#__PURE__*/React__default["default"].createElement("div", {
+          className: options.textClassName
+        }, displayData.text);
+      case exports.DisplayDataType.Html:
+        return /*#__PURE__*/React__default["default"].createElement("div", {
+          className: options.htmlClassName,
+          dangerouslySetInnerHTML: {
+            __html: displayData.html
+          }
+        });
+      default:
+        return /*#__PURE__*/React__default["default"].createElement("h1", null, "Unknown display type: ", displayData.type);
+    }
+  }
+  return {
+    render: function render(p, _ref13) {
+      var renderVisibility = _ref13.renderVisibility;
+      return renderVisibility(p.visible, doRender(p));
+    },
+    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, defaultLabel, renderers) {
+    if (props.array) {
+      return renderers.renderArray(props.array);
+    }
+    var renderType = props.renderOptions.type;
+    var fieldType = props.field.type;
+    var isBool = fieldType === exports.FieldType.Bool;
+    if (booleanOptions != null && isBool && props.options == null) {
+      return renderers.renderData(_extends({}, props, {
+        options: booleanOptions
+      }));
+    }
+    if (renderType === exports.DataRenderType.Standard && hasOptions(props)) {
+      return optionRenderer.render(props, defaultLabel, renderers);
+    }
+    switch (renderType) {
+      case exports.DataRenderType.Dropdown:
+        return selectRenderer.render(props, defaultLabel, renderers);
+    }
+    var l = defaultLabel();
+    return renderers.renderLabel(l, renderType === exports.DataRenderType.Checkbox ? /*#__PURE__*/React__default["default"].createElement(core.Fcheckbox, {
+      control: props.control
+    }) : /*#__PURE__*/React__default["default"].createElement(ControlInput, {
+      className: inputClass,
+      id: l.forId,
+      readOnly: props.readonly,
+      control: props.control,
+      convert: createInputConversion(props.field.type)
+    }));
+  });
+}
+function ControlInput(_ref14) {
+  var _effect2 = core.useComponentTracking();
+  try {
+    var control = _ref14.control,
+      convert = _ref14.convert,
+      props = _objectWithoutPropertiesLoose(_ref14, _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 {
+    _effect2();
+  }
+}
+function createDefaultAdornmentRenderer(options) {
+  return {
+    type: "adornment",
+    render: function render() {
+      return {};
+    }
+  };
+}
+function createDefaultVisibilityRenderer(options) {
+  return {
+    type: "visibility",
+    render: function render(visible, children) {
+      return visible.value ? children : /*#__PURE__*/React__default["default"].createElement(React__default["default"].Fragment, null);
+    }
+  };
+}
+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),
+    visibility: createDefaultVisibilityRenderer(),
+    adornment: createDefaultAdornmentRenderer()
+  };
+}
+function createClassStyledRenderers() {
+  return createDefaultRenderers({
+    label: {
+      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 isLabelRegistration(x) {
+  return x.type === "label";
+}
+function isActionRegistration(x) {
+  return x.type === "action";
+}
+function isVisibilityRegistration(x) {
+  return x.type === "visibility";
+}
+function isOneOf(x, v) {
+  return x == null ? true : Array.isArray(x) ? x.includes(v) : v === x;
+}
+function createDataRenderer(render, options) {
+  return _extends({
+    type: "data",
+    render: render
+  }, options);
+}
+function createDataRendererLabelled(_render, options) {
+  return _extends({
+    type: "data",
+    render: function render(props, defaultLabel, renderers) {
+      var dl = defaultLabel();
+      return renderers.renderLabel(dl, _render(props, dl.forId, renderers));
+    }
+  }, options);
+}
+function createLabelRenderer(options) {
+  return _extends({
+    type: "label"
+  }, options);
+}
+function createAdornmentRenderer(render, options) {
+  return _extends({
+    type: "adornment"
+  }, options, {
+    render: render
+  });
+}
+function createSelectRenderer(options) {
+  if (options === void 0) {
+    options = {};
+  }
+  return createDataRendererLabelled(function (props, id) {
+    return /*#__PURE__*/React__default["default"].createElement(SelectDataRenderer, {
+      className: options.className,
+      state: props.control,
+      id: id,
+      options: props.options,
+      required: props.required,
+      emptyText: options.emptyText,
+      requiredText: options.requiredText,
+      convert: createSelectConversion(props.field.type)
+    });
+  }, {
+    options: true
+  });
+}
+function SelectDataRenderer(_ref15) {
+  var _effect3 = core.useComponentTracking();
+  try {
+    var state = _ref15.state,
+      options = _ref15.options,
+      className = _ref15.className,
+      convert = _ref15.convert,
+      required = _ref15.required,
+      _ref15$emptyText = _ref15.emptyText,
+      emptyText = _ref15$emptyText === void 0 ? "N/A" : _ref15$emptyText,
+      _ref15$requiredText = _ref15.requiredText,
+      requiredText = _ref15$requiredText === void 0 ? "<please select>" : _ref15$requiredText,
+      props = _objectWithoutPropertiesLoose(_ref15, _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 {
+    _effect3();
+  }
+}
+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;
+      }];
+  }
+}
+
+var defaultTailwindTheme = {
+  label: {
+    className: "flex flex-col",
+    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"
+  },
+  group: {
+    standardClassName: "space-y-4",
+    gridClassName: "gap-x-2 gap-y-4"
+  },
+  action: {
+    className: "bg-primary rounded-lg p-3 text-white"
+  }
+};
 
+exports.AlwaysVisible = AlwaysVisible;
+exports.ControlInput = ControlInput;
+exports.DefaultBoolOptions = DefaultBoolOptions;
+exports.DefaultLabelRenderer = DefaultLabelRenderer;
 exports.FormRendererProvider = FormRendererProvider;
+exports.SelectDataRenderer = SelectDataRenderer;
+exports.addMissingControls = addMissingControls;
 exports.applyDefaultForField = applyDefaultForField;
 exports.applyDefaultValues = applyDefaultValues;
 exports.boolField = boolField;
@@ -578,11 +1546,32 @@ exports.buildSchema = buildSchema;
 exports.compoundField = compoundField;
 exports.controlForField = controlForField;
 exports.controlTitle = controlTitle;
+exports.createAction = createAction;
+exports.createAdornmentRenderer = createAdornmentRenderer;
+exports.createDataRenderer = createDataRenderer;
+exports.createDataRendererLabelled = createDataRendererLabelled;
+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.createDefaultSchemaHooks = createDefaultSchemaHooks;
+exports.createDefaultVisibilityRenderer = createDefaultVisibilityRenderer;
 exports.createFormEditHooks = createFormEditHooks;
+exports.createFormRenderer = createFormRenderer;
+exports.createInputConversion = createInputConversion;
+exports.createLabelRenderer = createLabelRenderer;
+exports.createSelectConversion = createSelectConversion;
+exports.createSelectRenderer = createSelectRenderer;
 exports.dataControl = dataControl;
 exports.defaultCompoundField = defaultCompoundField;
-exports.defaultExpressionHook = defaultExpressionHook;
+exports.defaultControlForField = defaultControlForField;
+exports.defaultFormEditHooks = defaultFormEditHooks;
 exports.defaultScalarField = defaultScalarField;
+exports.defaultTailwindTheme = defaultTailwindTheme;
 exports.defaultValueForField = defaultValueForField;
 exports.defaultValueForFields = defaultValueForFields;
 exports.elementValueForField = elementValueForField;
@@ -595,12 +1584,14 @@ exports.findField = findField;
 exports.findScalarField = findScalarField;
 exports.getDefaultScalarControlProperties = getDefaultScalarControlProperties;
 exports.getOptionsForScalarField = getOptionsForScalarField;
+exports.hasOptions = hasOptions;
 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;
@@ -609,10 +1600,12 @@ exports.makeScalarField = makeScalarField;
 exports.renderControl = renderControl;
 exports.stringField = stringField;
 exports.stringOptionsField = stringOptionsField;
+exports.useControlsWithDefaults = useControlsWithDefaults;
 exports.useDefaultValue = useDefaultValue;
 exports.useFormRendererComponents = useFormRendererComponents;
 exports.useIsControlVisible = useIsControlVisible;
 exports.visibility = visibility;
+exports.visitControlData = visitControlData;
 exports.visitControlDefinition = visitControlDefinition;
 exports.withScalarOptions = withScalarOptions;
 //# sourceMappingURL=index.js.map